@prisma/ts-builders 6.13.0-dev.2 → 6.13.0-dev.20

package/dist/ConditionalType.d.ts

@@ -0,0 +1,29 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class ConditionalType extends TypeBuilder {
+    #private;
+    needsParenthesisInUnion: boolean;
+    needsParenthesisInIntersection: boolean;
+    constructor(checkType: TypeBuilder, extendsType: TypeBuilder, trueType: TypeBuilder, falseType: TypeBuilder);
+    write(writer: Writer): void;
+}
+declare class ConditionalTypeBuilder {
+    check(checkType: TypeBuilder): ConditionalTypeBuilderWithCheckType;
+}
+declare class ConditionalTypeBuilderWithCheckType {
+    #private;
+    constructor(checkType: TypeBuilder);
+    extends(extendsType: TypeBuilder): ConditionalTypeBuilderWithExtendsType;
+}
+declare class ConditionalTypeBuilderWithExtendsType {
+    #private;
+    constructor(checkType: TypeBuilder, extendsType: TypeBuilder);
+    then(trueType: TypeBuilder): ConditionalTypeBuilderWithTrueType;
+}
+declare class ConditionalTypeBuilderWithTrueType {
+    #private;
+    constructor(checkType: TypeBuilder, extendsType: TypeBuilder, trueType: TypeBuilder);
+    else(falseType: TypeBuilder): ConditionalType;
+}
+export declare function conditionalType(): ConditionalTypeBuilder;
+export {};

package/dist/ConditionalType.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ConditionalType_exports = {};
+__export(ConditionalType_exports, {
+  ConditionalType: () => ConditionalType,
+  conditionalType: () => conditionalType
+});
+module.exports = __toCommonJS(ConditionalType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class ConditionalType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisInUnion = true;
+  needsParenthesisInIntersection = true;
+  #checkType;
+  #extendsType;
+  #trueType;
+  #falseType;
+  constructor(checkType, extendsType, trueType, falseType) {
+    super();
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+    this.#trueType = trueType;
+    this.#falseType = falseType;
+  }
+  write(writer) {
+    writer.write(this.#checkType);
+    writer.write(" extends ");
+    writer.write(this.#extendsType);
+    writer.write(" ? ");
+    writer.write(this.#trueType);
+    writer.write(" : ");
+    writer.write(this.#falseType);
+  }
+}
+class ConditionalTypeBuilder {
+  check(checkType) {
+    return new ConditionalTypeBuilderWithCheckType(checkType);
+  }
+}
+class ConditionalTypeBuilderWithCheckType {
+  #checkType;
+  constructor(checkType) {
+    this.#checkType = checkType;
+  }
+  extends(extendsType) {
+    return new ConditionalTypeBuilderWithExtendsType(this.#checkType, extendsType);
+  }
+}
+class ConditionalTypeBuilderWithExtendsType {
+  #checkType;
+  #extendsType;
+  constructor(checkType, extendsType) {
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+  }
+  then(trueType) {
+    return new ConditionalTypeBuilderWithTrueType(this.#checkType, this.#extendsType, trueType);
+  }
+}
+class ConditionalTypeBuilderWithTrueType {
+  #checkType;
+  #extendsType;
+  #trueType;
+  constructor(checkType, extendsType, trueType) {
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+    this.#trueType = trueType;
+  }
+  else(falseType) {
+    return new ConditionalType(this.#checkType, this.#extendsType, this.#trueType, falseType);
+  }
+}
+function conditionalType() {
+  return new ConditionalTypeBuilder();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConditionalType,
+  conditionalType
+});

package/dist/ConditionalType.mjs

@@ -0,0 +1,70 @@
+import { TypeBuilder } from "./TypeBuilder";
+class ConditionalType extends TypeBuilder {
+  needsParenthesisInUnion = true;
+  needsParenthesisInIntersection = true;
+  #checkType;
+  #extendsType;
+  #trueType;
+  #falseType;
+  constructor(checkType, extendsType, trueType, falseType) {
+    super();
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+    this.#trueType = trueType;
+    this.#falseType = falseType;
+  }
+  write(writer) {
+    writer.write(this.#checkType);
+    writer.write(" extends ");
+    writer.write(this.#extendsType);
+    writer.write(" ? ");
+    writer.write(this.#trueType);
+    writer.write(" : ");
+    writer.write(this.#falseType);
+  }
+}
+class ConditionalTypeBuilder {
+  check(checkType) {
+    return new ConditionalTypeBuilderWithCheckType(checkType);
+  }
+}
+class ConditionalTypeBuilderWithCheckType {
+  #checkType;
+  constructor(checkType) {
+    this.#checkType = checkType;
+  }
+  extends(extendsType) {
+    return new ConditionalTypeBuilderWithExtendsType(this.#checkType, extendsType);
+  }
+}
+class ConditionalTypeBuilderWithExtendsType {
+  #checkType;
+  #extendsType;
+  constructor(checkType, extendsType) {
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+  }
+  then(trueType) {
+    return new ConditionalTypeBuilderWithTrueType(this.#checkType, this.#extendsType, trueType);
+  }
+}
+class ConditionalTypeBuilderWithTrueType {
+  #checkType;
+  #extendsType;
+  #trueType;
+  constructor(checkType, extendsType, trueType) {
+    this.#checkType = checkType;
+    this.#extendsType = extendsType;
+    this.#trueType = trueType;
+  }
+  else(falseType) {
+    return new ConditionalType(this.#checkType, this.#extendsType, this.#trueType, falseType);
+  }
+}
+function conditionalType() {
+  return new ConditionalTypeBuilder();
+}
+export {
+  ConditionalType,
+  conditionalType
+};

package/dist/ConditionalType.test.d.ts

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

package/dist/ConditionalType.test.js

@@ -0,0 +1,114 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ArrayType = require("./ArrayType");
+var import_ConditionalType = require("./ConditionalType");
+var import_FunctionType = require("./FunctionType");
+var import_IntersectionType = require("./IntersectionType");
+var import_NamedType = require("./NamedType");
+var import_ObjectType = require("./ObjectType");
+var import_Parameter = require("./Parameter");
+var import_Property = require("./Property");
+var import_stringify = require("./stringify");
+var import_UnionType = require("./UnionType");
+const A = (0, import_NamedType.namedType)("A");
+const B = (0, import_NamedType.namedType)("B");
+const C = (0, import_NamedType.namedType)("C");
+const D = (0, import_NamedType.namedType)("D");
+(0, import_vitest.test)("basic conditional type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check(A).extends(B).then(C).else(D);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"A extends B ? C : D"`);
+});
+(0, import_vitest.test)("with union type as check type", () => {
+  const union = (0, import_UnionType.unionType)(A).addVariant(B);
+  const conditional = (0, import_ConditionalType.conditionalType)().check(union).extends(C).then((0, import_NamedType.namedType)("true")).else((0, import_NamedType.namedType)("false"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"A | B extends C ? true : false"`);
+});
+(0, import_vitest.test)("with array type as extends type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check(A).extends((0, import_ArrayType.array)(B)).then((0, import_NamedType.namedType)("IsArray")).else((0, import_NamedType.namedType)("NotArray"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"A extends B[] ? IsArray : NotArray"`);
+});
+(0, import_vitest.test)("with object types", () => {
+  const objType = (0, import_ObjectType.objectType)().add((0, import_Property.property)("name", (0, import_NamedType.namedType)("string"))).add((0, import_Property.property)("age", (0, import_NamedType.namedType)("number")));
+  const conditional = (0, import_ConditionalType.conditionalType)().check(A).extends(objType).then((0, import_NamedType.namedType)("IsObject")).else((0, import_NamedType.namedType)("NotObject"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`
+    "A extends {
+      name: string
+      age: number
+    } ? IsObject : NotObject"
+  `);
+});
+(0, import_vitest.test)("with function types", () => {
+  const funcType = (0, import_FunctionType.functionType)().addParameter((0, import_Parameter.parameter)("x", (0, import_NamedType.namedType)("string"))).setReturnType((0, import_NamedType.namedType)("number"));
+  const conditional = (0, import_ConditionalType.conditionalType)().check(A).extends(funcType).then((0, import_NamedType.namedType)("IsFunction")).else((0, import_NamedType.namedType)("NotFunction"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"A extends (x: string) => number ? IsFunction : NotFunction"`);
+});
+(0, import_vitest.test)("nested conditional types", () => {
+  const innerConditional = (0, import_ConditionalType.conditionalType)().check(A).extends(B).then(C).else(D);
+  const outerConditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("string")).then(innerConditional).else((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(outerConditional)).toMatchInlineSnapshot(`"T extends string ? A extends B ? C : D : never"`);
+});
+(0, import_vitest.test)("with generic types", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("U")).then((0, import_NamedType.namedType)("T")).else((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends U ? T : never"`);
+});
+(0, import_vitest.test)("complex real-world example", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_ArrayType.array)((0, import_NamedType.namedType)("any"))).then((0, import_NamedType.namedType)("T[0]")).else((0, import_NamedType.namedType)("T"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends any[] ? T[0] : T"`);
+});
+(0, import_vitest.test)("with literal types", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)('"foo"')).then((0, import_NamedType.namedType)("true")).else((0, import_NamedType.namedType)("false"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends "foo" ? true : false"`);
+});
+(0, import_vitest.test)("with intersection types", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)(A).addType(B);
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends(intersection).then((0, import_NamedType.namedType)("HasBoth")).else((0, import_NamedType.namedType)("NotBoth"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends A & B ? HasBoth : NotBoth"`);
+});
+(0, import_vitest.test)("with tuple types", () => {
+  const tupleType = (0, import_NamedType.namedType)("[string, number]");
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends(tupleType).then((0, import_NamedType.namedType)("IsTuple")).else((0, import_NamedType.namedType)("NotTuple"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends [string, number] ? IsTuple : NotTuple"`);
+});
+(0, import_vitest.test)("with keyof type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("K")).extends((0, import_NamedType.namedType)("keyof T")).then((0, import_NamedType.namedType)("K")).else((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"K extends keyof T ? K : never"`);
+});
+(0, import_vitest.test)("with never type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("never")).then((0, import_NamedType.namedType)("NeverReached")).else((0, import_NamedType.namedType)("NotNever"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends never ? NeverReached : NotNever"`);
+});
+(0, import_vitest.test)("with unknown type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("unknown")).then((0, import_NamedType.namedType)("AlwaysTrue")).else((0, import_NamedType.namedType)("NeverReached"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends unknown ? AlwaysTrue : NeverReached"`);
+});
+(0, import_vitest.test)("with any type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("any")).extends((0, import_NamedType.namedType)("T")).then((0, import_NamedType.namedType)("AnyExtendsT")).else((0, import_NamedType.namedType)("NotExtends"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"any extends T ? AnyExtendsT : NotExtends"`);
+});
+(0, import_vitest.test)("deeply nested conditional types", () => {
+  const deeplyNested = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("string")).then(
+    (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("U")).extends((0, import_NamedType.namedType)("number")).then(
+      (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("V")).extends((0, import_NamedType.namedType)("boolean")).then((0, import_NamedType.namedType)("AllMatch")).else((0, import_NamedType.namedType)("VNotBoolean"))
+    ).else((0, import_NamedType.namedType)("UNotNumber"))
+  ).else((0, import_NamedType.namedType)("TNotString"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(deeplyNested)).toMatchInlineSnapshot(
+    `"T extends string ? U extends number ? V extends boolean ? AllMatch : VNotBoolean : UNotNumber : TNotString"`
+  );
+});
+(0, import_vitest.test)("with template literal types", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("`prefix_${string}`")).then((0, import_NamedType.namedType)("HasPrefix")).else((0, import_NamedType.namedType)("NoPrefix"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends \`prefix_\${string}\` ? HasPrefix : NoPrefix"`);
+});
+(0, import_vitest.test)("with infer keyword", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("Promise<infer U>")).then((0, import_NamedType.namedType)("U")).else((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T extends Promise<infer U> ? U : never"`);
+});
+(0, import_vitest.test)("conditional type in union", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("string")).then((0, import_NamedType.namedType)("A")).else((0, import_NamedType.namedType)("B"));
+  const union = (0, import_UnionType.unionType)(conditional).addVariant((0, import_NamedType.namedType)("C"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(union)).toMatchInlineSnapshot(`"(T extends string ? A : B) | C"`);
+});
+(0, import_vitest.test)("with mapped type notation", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T[K]")).extends((0, import_NamedType.namedType)("Function")).then((0, import_NamedType.namedType)("K")).else((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(conditional)).toMatchInlineSnapshot(`"T[K] extends Function ? K : never"`);
+});

package/dist/ConditionalType.test.mjs

@@ -0,0 +1,113 @@
+import { expect, test } from "vitest";
+import { array } from "./ArrayType";
+import { conditionalType } from "./ConditionalType";
+import { functionType } from "./FunctionType";
+import { intersectionType } from "./IntersectionType";
+import { namedType } from "./NamedType";
+import { objectType } from "./ObjectType";
+import { parameter } from "./Parameter";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+import { unionType } from "./UnionType";
+const A = namedType("A");
+const B = namedType("B");
+const C = namedType("C");
+const D = namedType("D");
+test("basic conditional type", () => {
+  const conditional = conditionalType().check(A).extends(B).then(C).else(D);
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"A extends B ? C : D"`);
+});
+test("with union type as check type", () => {
+  const union = unionType(A).addVariant(B);
+  const conditional = conditionalType().check(union).extends(C).then(namedType("true")).else(namedType("false"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"A | B extends C ? true : false"`);
+});
+test("with array type as extends type", () => {
+  const conditional = conditionalType().check(A).extends(array(B)).then(namedType("IsArray")).else(namedType("NotArray"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"A extends B[] ? IsArray : NotArray"`);
+});
+test("with object types", () => {
+  const objType = objectType().add(property("name", namedType("string"))).add(property("age", namedType("number")));
+  const conditional = conditionalType().check(A).extends(objType).then(namedType("IsObject")).else(namedType("NotObject"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`
+    "A extends {
+      name: string
+      age: number
+    } ? IsObject : NotObject"
+  `);
+});
+test("with function types", () => {
+  const funcType = functionType().addParameter(parameter("x", namedType("string"))).setReturnType(namedType("number"));
+  const conditional = conditionalType().check(A).extends(funcType).then(namedType("IsFunction")).else(namedType("NotFunction"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"A extends (x: string) => number ? IsFunction : NotFunction"`);
+});
+test("nested conditional types", () => {
+  const innerConditional = conditionalType().check(A).extends(B).then(C).else(D);
+  const outerConditional = conditionalType().check(namedType("T")).extends(namedType("string")).then(innerConditional).else(namedType("never"));
+  expect(stringify(outerConditional)).toMatchInlineSnapshot(`"T extends string ? A extends B ? C : D : never"`);
+});
+test("with generic types", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("U")).then(namedType("T")).else(namedType("never"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends U ? T : never"`);
+});
+test("complex real-world example", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(array(namedType("any"))).then(namedType("T[0]")).else(namedType("T"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends any[] ? T[0] : T"`);
+});
+test("with literal types", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType('"foo"')).then(namedType("true")).else(namedType("false"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends "foo" ? true : false"`);
+});
+test("with intersection types", () => {
+  const intersection = intersectionType(A).addType(B);
+  const conditional = conditionalType().check(namedType("T")).extends(intersection).then(namedType("HasBoth")).else(namedType("NotBoth"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends A & B ? HasBoth : NotBoth"`);
+});
+test("with tuple types", () => {
+  const tupleType = namedType("[string, number]");
+  const conditional = conditionalType().check(namedType("T")).extends(tupleType).then(namedType("IsTuple")).else(namedType("NotTuple"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends [string, number] ? IsTuple : NotTuple"`);
+});
+test("with keyof type", () => {
+  const conditional = conditionalType().check(namedType("K")).extends(namedType("keyof T")).then(namedType("K")).else(namedType("never"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"K extends keyof T ? K : never"`);
+});
+test("with never type", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("never")).then(namedType("NeverReached")).else(namedType("NotNever"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends never ? NeverReached : NotNever"`);
+});
+test("with unknown type", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("unknown")).then(namedType("AlwaysTrue")).else(namedType("NeverReached"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends unknown ? AlwaysTrue : NeverReached"`);
+});
+test("with any type", () => {
+  const conditional = conditionalType().check(namedType("any")).extends(namedType("T")).then(namedType("AnyExtendsT")).else(namedType("NotExtends"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"any extends T ? AnyExtendsT : NotExtends"`);
+});
+test("deeply nested conditional types", () => {
+  const deeplyNested = conditionalType().check(namedType("T")).extends(namedType("string")).then(
+    conditionalType().check(namedType("U")).extends(namedType("number")).then(
+      conditionalType().check(namedType("V")).extends(namedType("boolean")).then(namedType("AllMatch")).else(namedType("VNotBoolean"))
+    ).else(namedType("UNotNumber"))
+  ).else(namedType("TNotString"));
+  expect(stringify(deeplyNested)).toMatchInlineSnapshot(
+    `"T extends string ? U extends number ? V extends boolean ? AllMatch : VNotBoolean : UNotNumber : TNotString"`
+  );
+});
+test("with template literal types", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("`prefix_${string}`")).then(namedType("HasPrefix")).else(namedType("NoPrefix"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends \`prefix_\${string}\` ? HasPrefix : NoPrefix"`);
+});
+test("with infer keyword", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("Promise<infer U>")).then(namedType("U")).else(namedType("never"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T extends Promise<infer U> ? U : never"`);
+});
+test("conditional type in union", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("string")).then(namedType("A")).else(namedType("B"));
+  const union = unionType(conditional).addVariant(namedType("C"));
+  expect(stringify(union)).toMatchInlineSnapshot(`"(T extends string ? A : B) | C"`);
+});
+test("with mapped type notation", () => {
+  const conditional = conditionalType().check(namedType("T[K]")).extends(namedType("Function")).then(namedType("K")).else(namedType("never"));
+  expect(stringify(conditional)).toMatchInlineSnapshot(`"T[K] extends Function ? K : never"`);
+});

package/dist/FunctionType.d.ts

@@ -6,6 +6,7 @@ export declare class FunctionType extends TypeBuilder {
     needsParenthesisWhenIndexed: boolean;
     needsParenthesisInKeyof: boolean;
     needsParenthesisInUnion: boolean;
+    needsParenthesisInIntersection: boolean;
     private returnType;
     private parameters;
     private genericParameters;

package/dist/FunctionType.js

@@ -28,6 +28,7 @@ class FunctionType extends import_TypeBuilder.TypeBuilder {
   needsParenthesisWhenIndexed = true;
   needsParenthesisInKeyof = true;
   needsParenthesisInUnion = true;
+  needsParenthesisInIntersection = true;
   returnType = import_PrimitiveType.voidType;
   parameters = [];
   genericParameters = [];

package/dist/FunctionType.mjs

@@ -4,6 +4,7 @@ class FunctionType extends TypeBuilder {
   needsParenthesisWhenIndexed = true;
   needsParenthesisInKeyof = true;
   needsParenthesisInUnion = true;
+  needsParenthesisInIntersection = true;
   returnType = voidType;
   parameters = [];
   genericParameters = [];

package/dist/GenericParameter.d.ts

@@ -3,7 +3,7 @@ import { NamedType } from './NamedType';
 import { TypeBuilder } from './TypeBuilder';
 import { Writer } from './Writer';
 export declare class GenericParameter implements BasicBuilder {
-    private name;
+    readonly name: string;
     private extendedType?;
     private defaultType?;
     constructor(name: string);

package/dist/IntersectionType.d.ts

@@ -0,0 +1,13 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class IntersectionType<MemberType extends TypeBuilder = TypeBuilder> extends TypeBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    needsParenthesisInKeyof: boolean;
+    readonly members: MemberType[];
+    constructor(firstType: MemberType);
+    addType(type: MemberType): this;
+    addTypes(types: MemberType[]): this;
+    write(writer: Writer): void;
+    mapTypes<NewMemberType extends TypeBuilder>(callback: (type: MemberType) => NewMemberType): IntersectionType<NewMemberType>;
+}
+export declare function intersectionType<MemberType extends TypeBuilder = TypeBuilder>(types: MemberType[] | MemberType): IntersectionType<MemberType>;

package/dist/IntersectionType.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IntersectionType_exports = {};
+__export(IntersectionType_exports, {
+  IntersectionType: () => IntersectionType,
+  intersectionType: () => intersectionType
+});
+module.exports = __toCommonJS(IntersectionType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class IntersectionType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  members;
+  constructor(firstType) {
+    super();
+    this.members = [firstType];
+  }
+  addType(type) {
+    this.members.push(type);
+    return this;
+  }
+  addTypes(types) {
+    for (const type of types) {
+      this.addType(type);
+    }
+    return this;
+  }
+  write(writer) {
+    writer.writeJoined(" & ", this.members, (member, writer2) => {
+      if (member.needsParenthesisInIntersection) {
+        writer2.write("(").write(member).write(")");
+      } else {
+        writer2.write(member);
+      }
+    });
+  }
+  mapTypes(callback) {
+    return intersectionType(this.members.map((m) => callback(m)));
+  }
+}
+function intersectionType(types) {
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      throw new TypeError("Intersection types array can not be empty");
+    }
+    const intersection = new IntersectionType(types[0]);
+    for (let i = 1; i < types.length; i++) {
+      intersection.addType(types[i]);
+    }
+    return intersection;
+  }
+  return new IntersectionType(types);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntersectionType,
+  intersectionType
+});

package/dist/IntersectionType.mjs

@@ -0,0 +1,49 @@
+import { TypeBuilder } from "./TypeBuilder";
+class IntersectionType extends TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  members;
+  constructor(firstType) {
+    super();
+    this.members = [firstType];
+  }
+  addType(type) {
+    this.members.push(type);
+    return this;
+  }
+  addTypes(types) {
+    for (const type of types) {
+      this.addType(type);
+    }
+    return this;
+  }
+  write(writer) {
+    writer.writeJoined(" & ", this.members, (member, writer2) => {
+      if (member.needsParenthesisInIntersection) {
+        writer2.write("(").write(member).write(")");
+      } else {
+        writer2.write(member);
+      }
+    });
+  }
+  mapTypes(callback) {
+    return intersectionType(this.members.map((m) => callback(m)));
+  }
+}
+function intersectionType(types) {
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      throw new TypeError("Intersection types array can not be empty");
+    }
+    const intersection = new IntersectionType(types[0]);
+    for (let i = 1; i < types.length; i++) {
+      intersection.addType(types[i]);
+    }
+    return intersection;
+  }
+  return new IntersectionType(types);
+}
+export {
+  IntersectionType,
+  intersectionType
+};

package/dist/IntersectionType.test.d.ts

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

package/dist/IntersectionType.test.js

@@ -0,0 +1,119 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ArrayType = require("./ArrayType");
+var import_ConditionalType = require("./ConditionalType");
+var import_FunctionType = require("./FunctionType");
+var import_IntersectionType = require("./IntersectionType");
+var import_NamedType = require("./NamedType");
+var import_ObjectType = require("./ObjectType");
+var import_Parameter = require("./Parameter");
+var import_Property = require("./Property");
+var import_stringify = require("./stringify");
+var import_UnionType = require("./UnionType");
+const A = (0, import_NamedType.namedType)("A");
+const B = (0, import_NamedType.namedType)("B");
+const C = (0, import_NamedType.namedType)("C");
+(0, import_vitest.test)("one type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_IntersectionType.intersectionType)(A))).toMatchInlineSnapshot(`"A"`);
+});
+(0, import_vitest.test)("multiple types", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_IntersectionType.intersectionType)(A).addType(B))).toMatchInlineSnapshot(`"A & B"`);
+});
+(0, import_vitest.test)("three types", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_IntersectionType.intersectionType)(A).addType(B).addType(C))).toMatchInlineSnapshot(`"A & B & C"`);
+});
+(0, import_vitest.test)("from array", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_IntersectionType.intersectionType)([A, B, C]))).toMatchInlineSnapshot(`"A & B & C"`);
+});
+(0, import_vitest.test)("with function type", () => {
+  const funcType = (0, import_FunctionType.functionType)().addParameter((0, import_Parameter.parameter)("x", (0, import_NamedType.namedType)("string"))).setReturnType((0, import_NamedType.namedType)("void"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_IntersectionType.intersectionType)([A, B, funcType]))).toMatchInlineSnapshot(`"A & B & ((x: string) => void)"`);
+});
+(0, import_vitest.test)("with object types", () => {
+  const obj1 = (0, import_ObjectType.objectType)().add((0, import_Property.property)("name", (0, import_NamedType.namedType)("string")));
+  const obj2 = (0, import_ObjectType.objectType)().add((0, import_Property.property)("age", (0, import_NamedType.namedType)("number")));
+  const intersection = (0, import_IntersectionType.intersectionType)(obj1).addType(obj2);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`
+    "{
+      name: string
+    } & {
+      age: number
+    }"
+  `);
+});
+(0, import_vitest.test)("with array types", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)((0, import_ArrayType.array)(A)).addType((0, import_ArrayType.array)(B));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"A[] & B[]"`);
+});
+(0, import_vitest.test)("with union types", () => {
+  const union1 = (0, import_UnionType.unionType)(A).addVariant(B);
+  const union2 = (0, import_UnionType.unionType)(C).addVariant((0, import_NamedType.namedType)("D"));
+  const intersection = (0, import_IntersectionType.intersectionType)(union1).addType(union2);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"(A | B) & (C | D)"`);
+});
+(0, import_vitest.test)("fails with empty array", () => {
+  (0, import_vitest.expect)(() => (0, import_IntersectionType.intersectionType)([])).toThrowErrorMatchingInlineSnapshot(
+    `[TypeError: Intersection types array can not be empty]`
+  );
+});
+(0, import_vitest.test)("mapTypes", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)([A, B, C]).mapTypes(import_ArrayType.array);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"A[] & B[] & C[]"`);
+});
+(0, import_vitest.test)("with generic types", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)((0, import_NamedType.namedType)("T")).addType((0, import_NamedType.namedType)("U"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"T & U"`);
+});
+(0, import_vitest.test)("with literal types", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)((0, import_NamedType.namedType)('"foo"')).addType((0, import_NamedType.namedType)('"bar"'));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`""foo" & "bar""`);
+});
+(0, import_vitest.test)("nested intersection types", () => {
+  const inner = (0, import_IntersectionType.intersectionType)(A).addType(B);
+  const outer = (0, import_IntersectionType.intersectionType)(inner).addType(C);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(outer)).toMatchInlineSnapshot(`"A & B & C"`);
+});
+(0, import_vitest.test)("with conditional type", () => {
+  const conditional = (0, import_ConditionalType.conditionalType)().check((0, import_NamedType.namedType)("T")).extends((0, import_NamedType.namedType)("string")).then(A).else(B);
+  const intersection = (0, import_IntersectionType.intersectionType)(conditional).addType(C);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"(T extends string ? A : B) & C"`);
+});
+(0, import_vitest.test)("with keyof type", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)((0, import_NamedType.namedType)("keyof T")).addType((0, import_NamedType.namedType)("string"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"keyof T & string"`);
+});
+(0, import_vitest.test)("complex real-world example", () => {
+  const baseType = (0, import_ObjectType.objectType)().add((0, import_Property.property)("id", (0, import_NamedType.namedType)("string"))).add((0, import_Property.property)("createdAt", (0, import_NamedType.namedType)("Date")));
+  const userFields = (0, import_ObjectType.objectType)().add((0, import_Property.property)("name", (0, import_NamedType.namedType)("string"))).add((0, import_Property.property)("email", (0, import_NamedType.namedType)("string")));
+  const permissions = (0, import_ObjectType.objectType)().add(
+    (0, import_Property.property)("role", (0, import_UnionType.unionType)((0, import_NamedType.namedType)('"admin"')).addVariant((0, import_NamedType.namedType)('"user"')))
+  );
+  const userType = (0, import_IntersectionType.intersectionType)(baseType).addType(userFields).addType(permissions);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(userType)).toMatchInlineSnapshot(`
+    "{
+      id: string
+      createdAt: Date
+    } & {
+      name: string
+      email: string
+    } & {
+      role: "admin" | "user"
+    }"
+  `);
+});
+(0, import_vitest.test)("addTypes with multiple types", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)(A).addTypes([B, C]);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"A & B & C"`);
+});
+(0, import_vitest.test)("with never type", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)(A).addType((0, import_NamedType.namedType)("never"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"A & never"`);
+});
+(0, import_vitest.test)("with unknown type", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)(A).addType((0, import_NamedType.namedType)("unknown"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"A & unknown"`);
+});
+(0, import_vitest.test)("with any type", () => {
+  const intersection = (0, import_IntersectionType.intersectionType)((0, import_NamedType.namedType)("any")).addType(B);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(intersection)).toMatchInlineSnapshot(`"any & B"`);
+});

package/dist/IntersectionType.test.mjs

@@ -0,0 +1,118 @@
+import { expect, test } from "vitest";
+import { array } from "./ArrayType";
+import { conditionalType } from "./ConditionalType";
+import { functionType } from "./FunctionType";
+import { intersectionType } from "./IntersectionType";
+import { namedType } from "./NamedType";
+import { objectType } from "./ObjectType";
+import { parameter } from "./Parameter";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+import { unionType } from "./UnionType";
+const A = namedType("A");
+const B = namedType("B");
+const C = namedType("C");
+test("one type", () => {
+  expect(stringify(intersectionType(A))).toMatchInlineSnapshot(`"A"`);
+});
+test("multiple types", () => {
+  expect(stringify(intersectionType(A).addType(B))).toMatchInlineSnapshot(`"A & B"`);
+});
+test("three types", () => {
+  expect(stringify(intersectionType(A).addType(B).addType(C))).toMatchInlineSnapshot(`"A & B & C"`);
+});
+test("from array", () => {
+  expect(stringify(intersectionType([A, B, C]))).toMatchInlineSnapshot(`"A & B & C"`);
+});
+test("with function type", () => {
+  const funcType = functionType().addParameter(parameter("x", namedType("string"))).setReturnType(namedType("void"));
+  expect(stringify(intersectionType([A, B, funcType]))).toMatchInlineSnapshot(`"A & B & ((x: string) => void)"`);
+});
+test("with object types", () => {
+  const obj1 = objectType().add(property("name", namedType("string")));
+  const obj2 = objectType().add(property("age", namedType("number")));
+  const intersection = intersectionType(obj1).addType(obj2);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`
+    "{
+      name: string
+    } & {
+      age: number
+    }"
+  `);
+});
+test("with array types", () => {
+  const intersection = intersectionType(array(A)).addType(array(B));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"A[] & B[]"`);
+});
+test("with union types", () => {
+  const union1 = unionType(A).addVariant(B);
+  const union2 = unionType(C).addVariant(namedType("D"));
+  const intersection = intersectionType(union1).addType(union2);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"(A | B) & (C | D)"`);
+});
+test("fails with empty array", () => {
+  expect(() => intersectionType([])).toThrowErrorMatchingInlineSnapshot(
+    `[TypeError: Intersection types array can not be empty]`
+  );
+});
+test("mapTypes", () => {
+  const intersection = intersectionType([A, B, C]).mapTypes(array);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"A[] & B[] & C[]"`);
+});
+test("with generic types", () => {
+  const intersection = intersectionType(namedType("T")).addType(namedType("U"));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"T & U"`);
+});
+test("with literal types", () => {
+  const intersection = intersectionType(namedType('"foo"')).addType(namedType('"bar"'));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`""foo" & "bar""`);
+});
+test("nested intersection types", () => {
+  const inner = intersectionType(A).addType(B);
+  const outer = intersectionType(inner).addType(C);
+  expect(stringify(outer)).toMatchInlineSnapshot(`"A & B & C"`);
+});
+test("with conditional type", () => {
+  const conditional = conditionalType().check(namedType("T")).extends(namedType("string")).then(A).else(B);
+  const intersection = intersectionType(conditional).addType(C);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"(T extends string ? A : B) & C"`);
+});
+test("with keyof type", () => {
+  const intersection = intersectionType(namedType("keyof T")).addType(namedType("string"));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"keyof T & string"`);
+});
+test("complex real-world example", () => {
+  const baseType = objectType().add(property("id", namedType("string"))).add(property("createdAt", namedType("Date")));
+  const userFields = objectType().add(property("name", namedType("string"))).add(property("email", namedType("string")));
+  const permissions = objectType().add(
+    property("role", unionType(namedType('"admin"')).addVariant(namedType('"user"')))
+  );
+  const userType = intersectionType(baseType).addType(userFields).addType(permissions);
+  expect(stringify(userType)).toMatchInlineSnapshot(`
+    "{
+      id: string
+      createdAt: Date
+    } & {
+      name: string
+      email: string
+    } & {
+      role: "admin" | "user"
+    }"
+  `);
+});
+test("addTypes with multiple types", () => {
+  const intersection = intersectionType(A).addTypes([B, C]);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"A & B & C"`);
+});
+test("with never type", () => {
+  const intersection = intersectionType(A).addType(namedType("never"));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"A & never"`);
+});
+test("with unknown type", () => {
+  const intersection = intersectionType(A).addType(namedType("unknown"));
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"A & unknown"`);
+});
+test("with any type", () => {
+  const intersection = intersectionType(namedType("any")).addType(B);
+  expect(stringify(intersection)).toMatchInlineSnapshot(`"any & B"`);
+});

package/dist/TypeBuilder.d.ts

@@ -5,6 +5,7 @@ export declare abstract class TypeBuilder implements BasicBuilder {
     needsParenthesisWhenIndexed: boolean;
     needsParenthesisInKeyof: boolean;
     needsParenthesisInUnion: boolean;
+    needsParenthesisInIntersection: boolean;
     abstract write(writer: Writer): void;
     subKey(key: string): KeyType;
     writeIndexed(writer: Writer): void;

package/dist/TypeBuilder.js

@@ -27,6 +27,7 @@ class TypeBuilder {
   needsParenthesisWhenIndexed = false;
   needsParenthesisInKeyof = false;
   needsParenthesisInUnion = false;
+  needsParenthesisInIntersection = false;
   subKey(key) {
     const { KeyType } = require("./KeyType");
     return new KeyType(this, key);

package/dist/TypeBuilder.mjs

@@ -4,6 +4,7 @@ class TypeBuilder {
   needsParenthesisWhenIndexed = false;
   needsParenthesisInKeyof = false;
   needsParenthesisInUnion = false;
+  needsParenthesisInIntersection = false;
   subKey(key) {
     const { KeyType } = require("./KeyType");
     return new KeyType(this, key);

package/dist/UnionType.d.ts

@@ -3,6 +3,7 @@ import { Writer } from './Writer';
 export declare class UnionType<VariantType extends TypeBuilder = TypeBuilder> extends TypeBuilder {
     needsParenthesisWhenIndexed: boolean;
     needsParenthesisInKeyof: boolean;
+    needsParenthesisInIntersection: boolean;
     readonly variants: VariantType[];
     constructor(firstType: VariantType);
     addVariant(variant: VariantType): this;

package/dist/UnionType.js

@@ -26,6 +26,7 @@ var import_TypeBuilder = require("./TypeBuilder");
 class UnionType extends import_TypeBuilder.TypeBuilder {
   needsParenthesisWhenIndexed = true;
   needsParenthesisInKeyof = true;
+  needsParenthesisInIntersection = true;
   variants;
   constructor(firstType) {
     super();

package/dist/UnionType.mjs

@@ -2,6 +2,7 @@ import { TypeBuilder } from "./TypeBuilder";
 class UnionType extends TypeBuilder {
   needsParenthesisWhenIndexed = true;
   needsParenthesisInKeyof = true;
+  needsParenthesisInIntersection = true;
   variants;
   constructor(firstType) {
     super();

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './ArraySpread';
 export * from './ArrayType';
 export * from './BasicBuilder';
 export * from './Class';
+export * from './ConditionalType';
 export * from './ConstDeclaration';
 export * from './DocComment';
 export * from './Export';
@@ -14,6 +15,7 @@ export * from './GenericParameter';
 export * from './helpers';
 export * from './Import';
 export * from './Interface';
+export * from './IntersectionType';
 export * from './KeyofType';
 export * from './KeyType';
 export * from './Method';

package/dist/index.js

@@ -20,6 +20,7 @@ __reExport(index_exports, require("./ArraySpread"), module.exports);
 __reExport(index_exports, require("./ArrayType"), module.exports);
 __reExport(index_exports, require("./BasicBuilder"), module.exports);
 __reExport(index_exports, require("./Class"), module.exports);
+__reExport(index_exports, require("./ConditionalType"), module.exports);
 __reExport(index_exports, require("./ConstDeclaration"), module.exports);
 __reExport(index_exports, require("./DocComment"), module.exports);
 __reExport(index_exports, require("./Export"), module.exports);
@@ -31,6 +32,7 @@ __reExport(index_exports, require("./GenericParameter"), module.exports);
 __reExport(index_exports, require("./helpers"), module.exports);
 __reExport(index_exports, require("./Import"), module.exports);
 __reExport(index_exports, require("./Interface"), module.exports);
+__reExport(index_exports, require("./IntersectionType"), module.exports);
 __reExport(index_exports, require("./KeyofType"), module.exports);
 __reExport(index_exports, require("./KeyType"), module.exports);
 __reExport(index_exports, require("./Method"), module.exports);
@@ -57,6 +59,7 @@ __reExport(index_exports, require("./Writer"), module.exports);
   ...require("./ArrayType"),
   ...require("./BasicBuilder"),
   ...require("./Class"),
+  ...require("./ConditionalType"),
   ...require("./ConstDeclaration"),
   ...require("./DocComment"),
   ...require("./Export"),
@@ -68,6 +71,7 @@ __reExport(index_exports, require("./Writer"), module.exports);
   ...require("./helpers"),
   ...require("./Import"),
   ...require("./Interface"),
+  ...require("./IntersectionType"),
   ...require("./KeyofType"),
   ...require("./KeyType"),
   ...require("./Method"),

package/dist/index.mjs

@@ -3,6 +3,7 @@ export * from "./ArraySpread";
 export * from "./ArrayType";
 export * from "./BasicBuilder";
 export * from "./Class";
+export * from "./ConditionalType";
 export * from "./ConstDeclaration";
 export * from "./DocComment";
 export * from "./Export";
@@ -14,6 +15,7 @@ export * from "./GenericParameter";
 export * from "./helpers";
 export * from "./Import";
 export * from "./Interface";
+export * from "./IntersectionType";
 export * from "./KeyofType";
 export * from "./KeyType";
 export * from "./Method";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/ts-builders",
-  "version": "6.13.0-dev.2",
+  "version": "6.13.0-dev.20",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,7 +24,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@prisma/internals": "6.13.0-dev.2"
+    "@prisma/internals": "6.13.0-dev.20"
   },
   "devDependencies": {
     "vitest": "3.0.9"