@prisma/ts-builders 6.6.0-dev.59

package/dist/KeyType.mjs

@@ -0,0 +1,19 @@
+import { TypeBuilder } from "./TypeBuilder";
+class KeyType extends 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);
+}
+export {
+  KeyType,
+  keyType
+};

package/dist/KeyType.test.d.ts

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

package/dist/KeyType.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ArrayType = require("./ArrayType");
+var import_FunctionType = require("./FunctionType");
+var import_KeyType = require("./KeyType");
+var import_NamedType = require("./NamedType");
+var import_ObjectType = require("./ObjectType");
+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)("simple only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyType.keyType)(A, "foo"))).toMatchInlineSnapshot(`"A["foo"]"`);
+});
+(0, import_vitest.test)("with object type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyType.keyType)((0, import_ObjectType.objectType)(), "toString"))).toMatchInlineSnapshot(`"({})["toString"]"`);
+});
+(0, import_vitest.test)("with array type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyType.keyType)((0, import_ArrayType.array)(A), "length"))).toMatchInlineSnapshot(`"A[]["length"]"`);
+});
+(0, import_vitest.test)("with function type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyType.keyType)((0, import_FunctionType.functionType)(), "length"))).toMatchInlineSnapshot(`"(() => void)["length"]"`);
+});
+(0, import_vitest.test)("with union type", () => {
+  const union = (0, import_UnionType.unionType)(A).addVariant(B).addVariant(C);
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyType.keyType)(union, "foo"))).toMatchInlineSnapshot(`"(A | B | C)["foo"]"`);
+});

package/dist/KeyType.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { array } from "./ArrayType";
+import { functionType } from "./FunctionType";
+import { keyType } from "./KeyType";
+import { namedType } from "./NamedType";
+import { objectType } from "./ObjectType";
+import { stringify } from "./stringify";
+import { unionType } from "./UnionType";
+const A = namedType("A");
+const B = namedType("B");
+const C = namedType("C");
+test("simple only", () => {
+  expect(stringify(keyType(A, "foo"))).toMatchInlineSnapshot(`"A["foo"]"`);
+});
+test("with object type", () => {
+  expect(stringify(keyType(objectType(), "toString"))).toMatchInlineSnapshot(`"({})["toString"]"`);
+});
+test("with array type", () => {
+  expect(stringify(keyType(array(A), "length"))).toMatchInlineSnapshot(`"A[]["length"]"`);
+});
+test("with function type", () => {
+  expect(stringify(keyType(functionType(), "length"))).toMatchInlineSnapshot(`"(() => void)["length"]"`);
+});
+test("with union type", () => {
+  const union = unionType(A).addVariant(B).addVariant(C);
+  expect(stringify(keyType(union, "foo"))).toMatchInlineSnapshot(`"(A | B | C)["foo"]"`);
+});

package/dist/KeyofType.d.ts

@@ -0,0 +1,8 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class KeyofType extends TypeBuilder {
+    baseType: TypeBuilder;
+    constructor(baseType: TypeBuilder);
+    write(writer: Writer): void;
+}
+export declare function keyOfType(baseType: TypeBuilder): KeyofType;

package/dist/KeyofType.js

@@ -0,0 +1,47 @@
+"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 KeyofType_exports = {};
+__export(KeyofType_exports, {
+  KeyofType: () => KeyofType,
+  keyOfType: () => keyOfType
+});
+module.exports = __toCommonJS(KeyofType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class KeyofType extends import_TypeBuilder.TypeBuilder {
+  constructor(baseType) {
+    super();
+    this.baseType = baseType;
+  }
+  write(writer) {
+    writer.write(`keyof `);
+    if (this.baseType.needsParenthesisInKeyof) {
+      writer.write("(").write(this.baseType).write(")");
+    } else {
+      writer.write(this.baseType);
+    }
+  }
+}
+function keyOfType(baseType) {
+  return new KeyofType(baseType);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyofType,
+  keyOfType
+});

package/dist/KeyofType.mjs

@@ -0,0 +1,22 @@
+import { TypeBuilder } from "./TypeBuilder";
+class KeyofType extends TypeBuilder {
+  constructor(baseType) {
+    super();
+    this.baseType = baseType;
+  }
+  write(writer) {
+    writer.write(`keyof `);
+    if (this.baseType.needsParenthesisInKeyof) {
+      writer.write("(").write(this.baseType).write(")");
+    } else {
+      writer.write(this.baseType);
+    }
+  }
+}
+function keyOfType(baseType) {
+  return new KeyofType(baseType);
+}
+export {
+  KeyofType,
+  keyOfType
+};

package/dist/KeyofType.test.d.ts

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

package/dist/KeyofType.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_ArrayType = require("./ArrayType");
+var import_FunctionType = require("./FunctionType");
+var import_KeyofType = require("./KeyofType");
+var import_NamedType = require("./NamedType");
+var import_ObjectType = require("./ObjectType");
+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)("simple only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyofType.keyOfType)(A))).toMatchInlineSnapshot(`"keyof A"`);
+});
+(0, import_vitest.test)("with object type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyofType.keyOfType)((0, import_ObjectType.objectType)()))).toMatchInlineSnapshot(`"keyof {}"`);
+});
+(0, import_vitest.test)("with array type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyofType.keyOfType)((0, import_ArrayType.array)(A)))).toMatchInlineSnapshot(`"keyof A[]"`);
+});
+(0, import_vitest.test)("with function type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyofType.keyOfType)((0, import_FunctionType.functionType)()))).toMatchInlineSnapshot(`"keyof (() => void)"`);
+});
+(0, import_vitest.test)("with union type", () => {
+  const union = (0, import_UnionType.unionType)(A).addVariant(B).addVariant(C);
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_KeyofType.keyOfType)(union))).toMatchInlineSnapshot(`"keyof (A | B | C)"`);
+});

package/dist/KeyofType.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { array } from "./ArrayType";
+import { functionType } from "./FunctionType";
+import { keyOfType } from "./KeyofType";
+import { namedType } from "./NamedType";
+import { objectType } from "./ObjectType";
+import { stringify } from "./stringify";
+import { unionType } from "./UnionType";
+const A = namedType("A");
+const B = namedType("B");
+const C = namedType("C");
+test("simple only", () => {
+  expect(stringify(keyOfType(A))).toMatchInlineSnapshot(`"keyof A"`);
+});
+test("with object type", () => {
+  expect(stringify(keyOfType(objectType()))).toMatchInlineSnapshot(`"keyof {}"`);
+});
+test("with array type", () => {
+  expect(stringify(keyOfType(array(A)))).toMatchInlineSnapshot(`"keyof A[]"`);
+});
+test("with function type", () => {
+  expect(stringify(keyOfType(functionType()))).toMatchInlineSnapshot(`"keyof (() => void)"`);
+});
+test("with union type", () => {
+  const union = unionType(A).addVariant(B).addVariant(C);
+  expect(stringify(keyOfType(union))).toMatchInlineSnapshot(`"keyof (A | B | C)"`);
+});

package/dist/Method.d.ts

@@ -0,0 +1,20 @@
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { GenericParameter } from './GenericParameter';
+import { Parameter } from './Parameter';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class Method implements BasicBuilder {
+    private name;
+    private docComment?;
+    private returnType;
+    private parameters;
+    private genericParameters;
+    constructor(name: string);
+    setDocComment(docComment: DocComment): this;
+    setReturnType(returnType: TypeBuilder): this;
+    addParameter(param: Parameter): this;
+    addGenericParameter(param: GenericParameter): this;
+    write(writer: Writer): void;
+}
+export declare function method(name: string): Method;

package/dist/Method.js

@@ -0,0 +1,75 @@
+"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 Method_exports = {};
+__export(Method_exports, {
+  Method: () => Method,
+  method: () => method
+});
+module.exports = __toCommonJS(Method_exports);
+var import_PrimitiveType = require("./PrimitiveType");
+class Method {
+  constructor(name) {
+    this.name = name;
+  }
+  docComment;
+  returnType = import_PrimitiveType.voidType;
+  parameters = [];
+  genericParameters = [];
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  setReturnType(returnType) {
+    this.returnType = returnType;
+    return this;
+  }
+  addParameter(param) {
+    this.parameters.push(param);
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write("(");
+    if (this.parameters.length > 0) {
+      writer.writeJoined(", ", this.parameters);
+    }
+    writer.write(")");
+    if (this.name !== "constructor") {
+      writer.write(": ").write(this.returnType);
+    }
+  }
+}
+function method(name) {
+  return new Method(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Method,
+  method
+});

package/dist/Method.mjs

@@ -0,0 +1,50 @@
+import { voidType } from "./PrimitiveType";
+class Method {
+  constructor(name) {
+    this.name = name;
+  }
+  docComment;
+  returnType = voidType;
+  parameters = [];
+  genericParameters = [];
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  setReturnType(returnType) {
+    this.returnType = returnType;
+    return this;
+  }
+  addParameter(param) {
+    this.parameters.push(param);
+    return this;
+  }
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write("(");
+    if (this.parameters.length > 0) {
+      writer.writeJoined(", ", this.parameters);
+    }
+    writer.write(")");
+    if (this.name !== "constructor") {
+      writer.write(": ").write(this.returnType);
+    }
+  }
+}
+function method(name) {
+  return new Method(name);
+}
+export {
+  Method,
+  method
+};

package/dist/Method.test.d.ts

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

package/dist/Method.test.js

@@ -0,0 +1,43 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_DocComment = require("./DocComment");
+var import_GenericParameter = require("./GenericParameter");
+var import_Method = require("./Method");
+var import_NamedType = require("./NamedType");
+var import_Parameter = require("./Parameter");
+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", () => {
+  const m = (0, import_Method.method)("doThings");
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings(): void"`);
+});
+(0, import_vitest.test)("with return type", () => {
+  const m = (0, import_Method.method)("doThings").setReturnType(A);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings(): A"`);
+});
+(0, import_vitest.test)("with doc comment", () => {
+  const m = (0, import_Method.method)("doThings").setDocComment((0, import_DocComment.docComment)("Does things"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`
+    "/**
+     * Does things
+     */
+    doThings(): void"
+  `);
+});
+(0, import_vitest.test)("with parameter", () => {
+  const m = (0, import_Method.method)("doThings").addParameter((0, import_Parameter.parameter)("foo", A));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings(foo: A): void"`);
+});
+(0, import_vitest.test)("with multiple parameters", () => {
+  const m = (0, import_Method.method)("doThings").addParameter((0, import_Parameter.parameter)("foo", A)).addParameter((0, import_Parameter.parameter)("foo", B));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings(foo: A, foo: B): void"`);
+});
+(0, import_vitest.test)("with generic parameter", () => {
+  const m = (0, import_Method.method)("doThings").addGenericParameter((0, import_GenericParameter.genericParameter)("T"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings<T>(): void"`);
+});
+(0, import_vitest.test)("with multiple generic parameters", () => {
+  const m = (0, import_Method.method)("doThings").addGenericParameter((0, import_GenericParameter.genericParameter)("T")).addGenericParameter((0, import_GenericParameter.genericParameter)("U"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(m)).toMatchInlineSnapshot(`"doThings<T, U>(): void"`);
+});

package/dist/Method.test.mjs

@@ -0,0 +1,42 @@
+import { expect, test } from "vitest";
+import { docComment } from "./DocComment";
+import { genericParameter } from "./GenericParameter";
+import { method } from "./Method";
+import { namedType } from "./NamedType";
+import { parameter } from "./Parameter";
+import { stringify } from "./stringify";
+const A = namedType("A");
+const B = namedType("B");
+test("name only", () => {
+  const m = method("doThings");
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings(): void"`);
+});
+test("with return type", () => {
+  const m = method("doThings").setReturnType(A);
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings(): A"`);
+});
+test("with doc comment", () => {
+  const m = method("doThings").setDocComment(docComment("Does things"));
+  expect(stringify(m)).toMatchInlineSnapshot(`
+    "/**
+     * Does things
+     */
+    doThings(): void"
+  `);
+});
+test("with parameter", () => {
+  const m = method("doThings").addParameter(parameter("foo", A));
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings(foo: A): void"`);
+});
+test("with multiple parameters", () => {
+  const m = method("doThings").addParameter(parameter("foo", A)).addParameter(parameter("foo", B));
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings(foo: A, foo: B): void"`);
+});
+test("with generic parameter", () => {
+  const m = method("doThings").addGenericParameter(genericParameter("T"));
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings<T>(): void"`);
+});
+test("with multiple generic parameters", () => {
+  const m = method("doThings").addGenericParameter(genericParameter("T")).addGenericParameter(genericParameter("U"));
+  expect(stringify(m)).toMatchInlineSnapshot(`"doThings<T, U>(): void"`);
+});

package/dist/NamedType.d.ts

@@ -0,0 +1,10 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class NamedType extends TypeBuilder {
+    readonly name: string;
+    readonly genericArguments: TypeBuilder[];
+    constructor(name: string);
+    addGenericArgument(type: TypeBuilder): this;
+    write(writer: Writer): void;
+}
+export declare function namedType(name: string): NamedType;

package/dist/NamedType.js

@@ -0,0 +1,50 @@
+"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 NamedType_exports = {};
+__export(NamedType_exports, {
+  NamedType: () => NamedType,
+  namedType: () => namedType
+});
+module.exports = __toCommonJS(NamedType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class NamedType extends import_TypeBuilder.TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  genericArguments = [];
+  addGenericArgument(type) {
+    this.genericArguments.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.genericArguments.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericArguments).write(">");
+    }
+  }
+}
+function namedType(name) {
+  return new NamedType(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamedType,
+  namedType
+});

package/dist/NamedType.mjs

@@ -0,0 +1,25 @@
+import { TypeBuilder } from "./TypeBuilder";
+class NamedType extends TypeBuilder {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  genericArguments = [];
+  addGenericArgument(type) {
+    this.genericArguments.push(type);
+    return this;
+  }
+  write(writer) {
+    writer.write(this.name);
+    if (this.genericArguments.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericArguments).write(">");
+    }
+  }
+}
+function namedType(name) {
+  return new NamedType(name);
+}
+export {
+  NamedType,
+  namedType
+};

package/dist/NamedType.test.d.ts

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

package/dist/NamedType.test.js

@@ -0,0 +1,15 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+(0, import_vitest.test)("name only", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType"))).toMatchInlineSnapshot(`"MyType"`);
+});
+(0, import_vitest.test)("with generic argument", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType").addGenericArgument((0, import_NamedType.namedType)("Foo")))).toMatchInlineSnapshot(`"MyType<Foo>"`);
+});
+(0, import_vitest.test)("with multiple generic arguments", () => {
+  (0, import_vitest.expect)(
+    (0, import_stringify.stringify)((0, import_NamedType.namedType)("MyType").addGenericArgument((0, import_NamedType.namedType)("Foo")).addGenericArgument((0, import_NamedType.namedType)("Bar")))
+  ).toMatchInlineSnapshot(`"MyType<Foo, Bar>"`);
+});

package/dist/NamedType.test.mjs

@@ -0,0 +1,14 @@
+import { expect, test } from "vitest";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+test("name only", () => {
+  expect(stringify(namedType("MyType"))).toMatchInlineSnapshot(`"MyType"`);
+});
+test("with generic argument", () => {
+  expect(stringify(namedType("MyType").addGenericArgument(namedType("Foo")))).toMatchInlineSnapshot(`"MyType<Foo>"`);
+});
+test("with multiple generic arguments", () => {
+  expect(
+    stringify(namedType("MyType").addGenericArgument(namedType("Foo")).addGenericArgument(namedType("Bar")))
+  ).toMatchInlineSnapshot(`"MyType<Foo, Bar>"`);
+});

package/dist/NamespaceDeclaration.d.ts

@@ -0,0 +1,13 @@
+import { AnyDeclarationBuilder } from './AnyDeclarationBuilder';
+import { BasicBuilder } from './BasicBuilder';
+import { Export } from './Export';
+import { Writer } from './Writer';
+export type NamespaceItem = AnyDeclarationBuilder | Export<AnyDeclarationBuilder>;
+export declare class NamespaceDeclaration implements BasicBuilder {
+    readonly name: string;
+    private items;
+    constructor(name: string);
+    add(declaration: NamespaceItem): void;
+    write(writer: Writer<undefined>): void;
+}
+export declare function namespace(name: string): NamespaceDeclaration;

package/dist/NamespaceDeclaration.js

@@ -0,0 +1,48 @@
+"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 NamespaceDeclaration_exports = {};
+__export(NamespaceDeclaration_exports, {
+  NamespaceDeclaration: () => NamespaceDeclaration,
+  namespace: () => namespace
+});
+module.exports = __toCommonJS(NamespaceDeclaration_exports);
+class NamespaceDeclaration {
+  constructor(name) {
+    this.name = name;
+  }
+  items = [];
+  add(declaration) {
+    this.items.push(declaration);
+  }
+  write(writer) {
+    writer.writeLine(`namespace ${this.name} {`).withIndent(() => {
+      for (const item of this.items) {
+        writer.writeLine(item);
+      }
+    }).write("}");
+  }
+}
+function namespace(name) {
+  return new NamespaceDeclaration(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespaceDeclaration,
+  namespace
+});