@prisma/ts-builders 6.6.0-dev.59

package/dist/GenericParameter.test.js

@@ -0,0 +1,19 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_GenericParameter = require("./GenericParameter");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+const B = (0, import_NamedType.namedType)("B");
+(0, import_vitest.test)("name only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_GenericParameter.genericParameter)("T"))).toMatchInlineSnapshot(`"T"`);
+});
+(0, import_vitest.test)("with extends", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_GenericParameter.genericParameter)("T").extends(A))).toMatchInlineSnapshot(`"T extends A"`);
+});
+(0, import_vitest.test)("with default", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_GenericParameter.genericParameter)("T").default(B))).toMatchInlineSnapshot(`"T = B"`);
+});
+(0, import_vitest.test)("with extends + default", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_GenericParameter.genericParameter)("T").extends(A).default(B))).toMatchInlineSnapshot(`"T extends A = B"`);
+});

package/dist/GenericParameter.test.mjs

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest";
+import { genericParameter } from "./GenericParameter";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+const A = namedType("A");
+const B = namedType("B");
+test("name only", () => {
+  expect(stringify(genericParameter("T"))).toMatchInlineSnapshot(`"T"`);
+});
+test("with extends", () => {
+  expect(stringify(genericParameter("T").extends(A))).toMatchInlineSnapshot(`"T extends A"`);
+});
+test("with default", () => {
+  expect(stringify(genericParameter("T").default(B))).toMatchInlineSnapshot(`"T = B"`);
+});
+test("with extends + default", () => {
+  expect(stringify(genericParameter("T").extends(A).default(B))).toMatchInlineSnapshot(`"T extends A = B"`);
+});

package/dist/Import.d.ts

@@ -0,0 +1,36 @@
+import { BasicBuilder } from './BasicBuilder';
+import { Writer } from './Writer';
+export type Import = NamespaceImport | BindingsImport | ModuleImport;
+export declare class NamespaceImport implements BasicBuilder {
+    readonly alias: string;
+    readonly from: string;
+    constructor(alias: string, from: string);
+    write(writer: Writer<undefined>): void;
+}
+export declare class BindingsImport implements BasicBuilder {
+    readonly from: string;
+    private defaultImport;
+    private namedImports;
+    constructor(from: string);
+    default(name: string): this;
+    named(namedImport: string | NamedImport): this;
+    write(writer: Writer): void;
+    private hasNamedImports;
+}
+export declare class NamedImport implements BasicBuilder {
+    readonly name: string;
+    private alias;
+    constructor(name: string);
+    as(alias: string): this;
+    write(writer: Writer): void;
+}
+export declare class ModuleImport implements BasicBuilder {
+    readonly from: string;
+    constructor(from: string);
+    asNamespace(alias: string): NamespaceImport;
+    default(alias: string): BindingsImport;
+    named(namedImport: string | NamedImport): BindingsImport;
+    write(writer: Writer): void;
+}
+export declare function moduleImport(from: string): ModuleImport;
+export declare function namedImport(name: string): NamedImport;

package/dist/Import.js

@@ -0,0 +1,119 @@
+"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 Import_exports = {};
+__export(Import_exports, {
+  BindingsImport: () => BindingsImport,
+  ModuleImport: () => ModuleImport,
+  NamedImport: () => NamedImport,
+  NamespaceImport: () => NamespaceImport,
+  moduleImport: () => moduleImport,
+  namedImport: () => namedImport
+});
+module.exports = __toCommonJS(Import_exports);
+class NamespaceImport {
+  constructor(alias, from) {
+    this.alias = alias;
+    this.from = from;
+  }
+  write(writer) {
+    writer.write("import * as ").write(this.alias).write(` from "${this.from}"`);
+  }
+}
+class BindingsImport {
+  constructor(from) {
+    this.from = from;
+  }
+  defaultImport;
+  namedImports = [];
+  default(name) {
+    this.defaultImport = name;
+    return this;
+  }
+  named(namedImport2) {
+    if (typeof namedImport2 === "string") {
+      namedImport2 = new NamedImport(namedImport2);
+    }
+    this.namedImports.push(namedImport2);
+    return this;
+  }
+  write(writer) {
+    writer.write("import ");
+    if (this.defaultImport) {
+      writer.write(this.defaultImport);
+      if (this.hasNamedImports()) {
+        writer.write(", ");
+      }
+    }
+    if (this.hasNamedImports()) {
+      writer.write("{ ").writeJoined(", ", this.namedImports).write(" }");
+    }
+    writer.write(` from "${this.from}"`);
+  }
+  hasNamedImports() {
+    return this.namedImports.length > 0;
+  }
+}
+class NamedImport {
+  constructor(name) {
+    this.name = name;
+  }
+  alias;
+  as(alias) {
+    this.alias = alias;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.alias) {
+      writer.write(" as ").write(this.alias);
+    }
+  }
+}
+class ModuleImport {
+  constructor(from) {
+    this.from = from;
+  }
+  asNamespace(alias) {
+    return new NamespaceImport(alias, this.from);
+  }
+  default(alias) {
+    return new BindingsImport(this.from).default(alias);
+  }
+  named(namedImport2) {
+    return new BindingsImport(this.from).named(namedImport2);
+  }
+  write(writer) {
+    writer.write("import ").write(`"${this.from}"`);
+  }
+}
+function moduleImport(from) {
+  return new ModuleImport(from);
+}
+function namedImport(name) {
+  return new NamedImport(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BindingsImport,
+  ModuleImport,
+  NamedImport,
+  NamespaceImport,
+  moduleImport,
+  namedImport
+});

package/dist/Import.mjs

@@ -0,0 +1,90 @@
+class NamespaceImport {
+  constructor(alias, from) {
+    this.alias = alias;
+    this.from = from;
+  }
+  write(writer) {
+    writer.write("import * as ").write(this.alias).write(` from "${this.from}"`);
+  }
+}
+class BindingsImport {
+  constructor(from) {
+    this.from = from;
+  }
+  defaultImport;
+  namedImports = [];
+  default(name) {
+    this.defaultImport = name;
+    return this;
+  }
+  named(namedImport2) {
+    if (typeof namedImport2 === "string") {
+      namedImport2 = new NamedImport(namedImport2);
+    }
+    this.namedImports.push(namedImport2);
+    return this;
+  }
+  write(writer) {
+    writer.write("import ");
+    if (this.defaultImport) {
+      writer.write(this.defaultImport);
+      if (this.hasNamedImports()) {
+        writer.write(", ");
+      }
+    }
+    if (this.hasNamedImports()) {
+      writer.write("{ ").writeJoined(", ", this.namedImports).write(" }");
+    }
+    writer.write(` from "${this.from}"`);
+  }
+  hasNamedImports() {
+    return this.namedImports.length > 0;
+  }
+}
+class NamedImport {
+  constructor(name) {
+    this.name = name;
+  }
+  alias;
+  as(alias) {
+    this.alias = alias;
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.alias) {
+      writer.write(" as ").write(this.alias);
+    }
+  }
+}
+class ModuleImport {
+  constructor(from) {
+    this.from = from;
+  }
+  asNamespace(alias) {
+    return new NamespaceImport(alias, this.from);
+  }
+  default(alias) {
+    return new BindingsImport(this.from).default(alias);
+  }
+  named(namedImport2) {
+    return new BindingsImport(this.from).named(namedImport2);
+  }
+  write(writer) {
+    writer.write("import ").write(`"${this.from}"`);
+  }
+}
+function moduleImport(from) {
+  return new ModuleImport(from);
+}
+function namedImport(name) {
+  return new NamedImport(name);
+}
+export {
+  BindingsImport,
+  ModuleImport,
+  NamedImport,
+  NamespaceImport,
+  moduleImport,
+  namedImport
+};

package/dist/Import.test.d.ts

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

package/dist/Import.test.js

@@ -0,0 +1,33 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_Import = require("./Import");
+var import_stringify = require("./stringify");
+(0, import_vitest.test)("module name only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_Import.moduleImport)("someModule"))).toMatchInlineSnapshot(`"import "someModule""`);
+});
+(0, import_vitest.test)("default", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").default("mod");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(`"import mod from "myModule""`);
+});
+(0, import_vitest.test)("namespace", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").asNamespace("ns");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(`"import * as ns from "myModule""`);
+});
+(0, import_vitest.test)("named", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").named("func");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(`"import { func } from "myModule""`);
+});
+(0, import_vitest.test)("named with alias", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").named((0, import_Import.namedImport)("func").as("myFunc"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(`"import { func as myFunc } from "myModule""`);
+});
+(0, import_vitest.test)("multiple named", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").named("func1").named("func2").named((0, import_Import.namedImport)("func3").as("aliasedFunc3"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(
+    `"import { func1, func2, func3 as aliasedFunc3 } from "myModule""`
+  );
+});
+(0, import_vitest.test)("default and named", () => {
+  const importDecl = (0, import_Import.moduleImport)("myModule").default("mod").named("func1").named("func2");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(importDecl)).toMatchInlineSnapshot(`"import mod, { func1, func2 } from "myModule""`);
+});

package/dist/Import.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+import { moduleImport, namedImport } from "./Import";
+import { stringify } from "./stringify";
+test("module name only", () => {
+  expect(stringify(moduleImport("someModule"))).toMatchInlineSnapshot(`"import "someModule""`);
+});
+test("default", () => {
+  const importDecl = moduleImport("myModule").default("mod");
+  expect(stringify(importDecl)).toMatchInlineSnapshot(`"import mod from "myModule""`);
+});
+test("namespace", () => {
+  const importDecl = moduleImport("myModule").asNamespace("ns");
+  expect(stringify(importDecl)).toMatchInlineSnapshot(`"import * as ns from "myModule""`);
+});
+test("named", () => {
+  const importDecl = moduleImport("myModule").named("func");
+  expect(stringify(importDecl)).toMatchInlineSnapshot(`"import { func } from "myModule""`);
+});
+test("named with alias", () => {
+  const importDecl = moduleImport("myModule").named(namedImport("func").as("myFunc"));
+  expect(stringify(importDecl)).toMatchInlineSnapshot(`"import { func as myFunc } from "myModule""`);
+});
+test("multiple named", () => {
+  const importDecl = moduleImport("myModule").named("func1").named("func2").named(namedImport("func3").as("aliasedFunc3"));
+  expect(stringify(importDecl)).toMatchInlineSnapshot(
+    `"import { func1, func2, func3 as aliasedFunc3 } from "myModule""`
+  );
+});
+test("default and named", () => {
+  const importDecl = moduleImport("myModule").default("mod").named("func1").named("func2");
+  expect(stringify(importDecl)).toMatchInlineSnapshot(`"import mod, { func1, func2 } from "myModule""`);
+});

package/dist/Interface.d.ts

@@ -0,0 +1,22 @@
+import { GenericParameter } from './GenericParameter';
+import { Method } from './Method';
+import { NamedType } from './NamedType';
+import { Property } from './Property';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+type InterfaceItem = Method | Property;
+export declare class InterfaceDeclaration extends TypeBuilder {
+    readonly name: string;
+    needsParenthesisWhenIndexed: boolean;
+    private items;
+    private genericParameters;
+    private extendedTypes;
+    constructor(name: string);
+    add(item: InterfaceItem): this;
+    addMultiple(items: InterfaceItem[]): this;
+    addGenericParameter(param: GenericParameter): this;
+    extends(type: NamedType): this;
+    write(writer: Writer): void;
+}
+export declare function interfaceDeclaration(name: string): InterfaceDeclaration;
+export {};

package/dist/Interface.js

@@ -0,0 +1,79 @@
+"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 Interface_exports = {};
+__export(Interface_exports, {
+  InterfaceDeclaration: () => InterfaceDeclaration,
+  interfaceDeclaration: () => interfaceDeclaration
+});
+module.exports = __toCommonJS(Interface_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class InterfaceDeclaration extends import_TypeBuilder.TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  needsParenthesisWhenIndexed = true;
+  items = [];
+  genericParameters = [];
+  extendedTypes = [];
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  extends(type) {
+    this.extendedTypes.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write("interface ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    if (this.extendedTypes.length > 0) {
+      writer.write(" extends ").writeJoined(", ", this.extendedTypes);
+    }
+    if (this.items.length === 0) {
+      writer.writeLine(" {}");
+      return;
+    }
+    writer.writeLine(" {").withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+}
+function interfaceDeclaration(name) {
+  return new InterfaceDeclaration(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterfaceDeclaration,
+  interfaceDeclaration
+});

package/dist/Interface.mjs

@@ -0,0 +1,54 @@
+import { TypeBuilder } from "./TypeBuilder";
+class InterfaceDeclaration extends TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  needsParenthesisWhenIndexed = true;
+  items = [];
+  genericParameters = [];
+  extendedTypes = [];
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addMultiple(items) {
+    for (const item of items) {
+      this.add(item);
+    }
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  extends(type) {
+    this.extendedTypes.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write("interface ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    if (this.extendedTypes.length > 0) {
+      writer.write(" extends ").writeJoined(", ", this.extendedTypes);
+    }
+    if (this.items.length === 0) {
+      writer.writeLine(" {}");
+      return;
+    }
+    writer.writeLine(" {").withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+}
+function interfaceDeclaration(name) {
+  return new InterfaceDeclaration(name);
+}
+export {
+  InterfaceDeclaration,
+  interfaceDeclaration
+};

package/dist/Interface.test.d.ts

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

package/dist/Interface.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_GenericParameter = require("./GenericParameter");
+var import_Interface = require("./Interface");
+var import_Method = require("./Method");
+var import_NamedType = require("./NamedType");
+var import_Property = require("./Property");
+var import_stringify = require("./stringify");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("empty", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("MyInterface");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface MyInterface {}
+    "
+  `);
+});
+(0, import_vitest.test)("with property", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("SomeInterface").add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("with method", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("MyInterface").add((0, import_Method.method)("doThing"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface MyInterface {
+      doThing(): void
+    }"
+  `);
+});
+(0, import_vitest.test)("with generic parameter", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("SomeInterface").addGenericParameter((0, import_GenericParameter.genericParameter)("T").extends((0, import_NamedType.namedType)("U"))).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface<T extends U> {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("extending the type", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("SomeInterface").extends((0, import_NamedType.namedType)("Foo")).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface extends Foo {
+      foo: A
+    }"
+  `);
+});
+(0, import_vitest.test)("extending multiple types", () => {
+  const obj = (0, import_Interface.interfaceDeclaration)("SomeInterface").extends((0, import_NamedType.namedType)("Foo")).extends((0, import_NamedType.namedType)("Bar")).add((0, import_Property.property)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface extends Foo, Bar {
+      foo: A
+    }"
+  `);
+});

package/dist/Interface.test.mjs

@@ -0,0 +1,55 @@
+import { expect, test } from "vitest";
+import { genericParameter } from "./GenericParameter";
+import { interfaceDeclaration } from "./Interface";
+import { method } from "./Method";
+import { namedType } from "./NamedType";
+import { property } from "./Property";
+import { stringify } from "./stringify";
+const A = namedType("A");
+test("empty", () => {
+  const obj = interfaceDeclaration("MyInterface");
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface MyInterface {}
+    "
+  `);
+});
+test("with property", () => {
+  const obj = interfaceDeclaration("SomeInterface").add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface {
+      foo: A
+    }"
+  `);
+});
+test("with method", () => {
+  const obj = interfaceDeclaration("MyInterface").add(method("doThing"));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface MyInterface {
+      doThing(): void
+    }"
+  `);
+});
+test("with generic parameter", () => {
+  const obj = interfaceDeclaration("SomeInterface").addGenericParameter(genericParameter("T").extends(namedType("U"))).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface<T extends U> {
+      foo: A
+    }"
+  `);
+});
+test("extending the type", () => {
+  const obj = interfaceDeclaration("SomeInterface").extends(namedType("Foo")).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface extends Foo {
+      foo: A
+    }"
+  `);
+});
+test("extending multiple types", () => {
+  const obj = interfaceDeclaration("SomeInterface").extends(namedType("Foo")).extends(namedType("Bar")).add(property("foo", A));
+  expect(stringify(obj)).toMatchInlineSnapshot(`
+    "interface SomeInterface extends Foo, Bar {
+      foo: A
+    }"
+  `);
+});

package/dist/KeyType.d.ts

@@ -0,0 +1,9 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class KeyType extends TypeBuilder {
+    baseType: TypeBuilder;
+    key: string;
+    constructor(baseType: TypeBuilder, key: string);
+    write(writer: Writer): void;
+}
+export declare function keyType(baseType: TypeBuilder, key: string): KeyType;

package/dist/KeyType.js

@@ -0,0 +1,44 @@
+"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 KeyType_exports = {};
+__export(KeyType_exports, {
+  KeyType: () => KeyType,
+  keyType: () => keyType
+});
+module.exports = __toCommonJS(KeyType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class KeyType extends import_TypeBuilder.TypeBuilder {
+  constructor(baseType, key) {
+    super();
+    this.baseType = baseType;
+    this.key = key;
+  }
+  write(writer) {
+    this.baseType.writeIndexed(writer);
+    writer.write("[").write(`"${this.key}"`).write("]");
+  }
+}
+function keyType(baseType, key) {
+  return new KeyType(baseType, key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyType,
+  keyType
+});