@prisma/ts-builders 6.6.0-dev.100

package/dist/TypeBuilder.mjs

@@ -0,0 +1,23 @@
+class TypeBuilder {
+  // TODO(@SevInf): this should be replaced with precedence system that would
+  // automatically add parenthesis where they are needed
+  needsParenthesisWhenIndexed = false;
+  needsParenthesisInKeyof = false;
+  needsParenthesisInUnion = false;
+  subKey(key) {
+    const { KeyType } = require("./KeyType");
+    return new KeyType(this, key);
+  }
+  writeIndexed(writer) {
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write("(");
+    }
+    writer.write(this);
+    if (this.needsParenthesisWhenIndexed) {
+      writer.write(")");
+    }
+  }
+}
+export {
+  TypeBuilder
+};

package/dist/TypeDeclaration.d.ts

@@ -0,0 +1,17 @@
+import { BasicBuilder } from './BasicBuilder';
+import { DocComment } from './DocComment';
+import { GenericParameter } from './GenericParameter';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class TypeDeclaration<InnerType extends TypeBuilder = TypeBuilder> implements BasicBuilder {
+    name: string;
+    readonly type: InnerType;
+    private genericParameters;
+    private docComment?;
+    constructor(name: string, type: InnerType);
+    addGenericParameter(param: GenericParameter): this;
+    setName(name: string): this;
+    setDocComment(docComment: DocComment): this;
+    write(writer: Writer): void;
+}
+export declare function typeDeclaration<InnerType extends TypeBuilder = TypeBuilder>(name: string, type: InnerType): TypeDeclaration<InnerType>;

package/dist/TypeDeclaration.js

@@ -0,0 +1,62 @@
+"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 TypeDeclaration_exports = {};
+__export(TypeDeclaration_exports, {
+  TypeDeclaration: () => TypeDeclaration,
+  typeDeclaration: () => typeDeclaration
+});
+module.exports = __toCommonJS(TypeDeclaration_exports);
+class TypeDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  genericParameters = [];
+  docComment;
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("type ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write(" = ").write(this.type);
+  }
+}
+function typeDeclaration(name, type) {
+  return new TypeDeclaration(name, type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeDeclaration,
+  typeDeclaration
+});

package/dist/TypeDeclaration.mjs

@@ -0,0 +1,37 @@
+class TypeDeclaration {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  genericParameters = [];
+  docComment;
+  addGenericParameter(param) {
+    this.genericParameters.push(param);
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDocComment(docComment) {
+    this.docComment = docComment;
+    return this;
+  }
+  write(writer) {
+    if (this.docComment) {
+      writer.write(this.docComment);
+    }
+    writer.write("type ").write(this.name);
+    if (this.genericParameters.length > 0) {
+      writer.write("<").writeJoined(", ", this.genericParameters).write(">");
+    }
+    writer.write(" = ").write(this.type);
+  }
+}
+function typeDeclaration(name, type) {
+  return new TypeDeclaration(name, type);
+}
+export {
+  TypeDeclaration,
+  typeDeclaration
+};

package/dist/TypeDeclaration.test.d.ts

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

package/dist/TypeDeclaration.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_DocComment = require("./DocComment");
+var import_GenericParameter = require("./GenericParameter");
+var import_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+var import_TypeDeclaration = require("./TypeDeclaration");
+const A = (0, import_NamedType.namedType)("A");
+(0, import_vitest.test)("basic", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_TypeDeclaration.typeDeclaration)("B", A))).toMatchInlineSnapshot(`"type B = A"`);
+});
+(0, import_vitest.test)("with doc comment", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).setDocComment((0, import_DocComment.docComment)("Type for stuff"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Type for stuff
+     */
+    type B = A"
+  `);
+});
+(0, import_vitest.test)("with generic parameters", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).addGenericParameter((0, import_GenericParameter.genericParameter)("T"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`"type B<T> = A"`);
+});
+(0, import_vitest.test)("with multiple generic parameters", () => {
+  const decl = (0, import_TypeDeclaration.typeDeclaration)("B", A).addGenericParameter((0, import_GenericParameter.genericParameter)("T")).addGenericParameter((0, import_GenericParameter.genericParameter)("U"));
+  (0, import_vitest.expect)((0, import_stringify.stringify)(decl)).toMatchInlineSnapshot(`"type B<T, U> = A"`);
+});

package/dist/TypeDeclaration.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { docComment } from "./DocComment";
+import { genericParameter } from "./GenericParameter";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+import { typeDeclaration } from "./TypeDeclaration";
+const A = namedType("A");
+test("basic", () => {
+  expect(stringify(typeDeclaration("B", A))).toMatchInlineSnapshot(`"type B = A"`);
+});
+test("with doc comment", () => {
+  const decl = typeDeclaration("B", A).setDocComment(docComment("Type for stuff"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`
+    "/**
+     * Type for stuff
+     */
+    type B = A"
+  `);
+});
+test("with generic parameters", () => {
+  const decl = typeDeclaration("B", A).addGenericParameter(genericParameter("T"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`"type B<T> = A"`);
+});
+test("with multiple generic parameters", () => {
+  const decl = typeDeclaration("B", A).addGenericParameter(genericParameter("T")).addGenericParameter(genericParameter("U"));
+  expect(stringify(decl)).toMatchInlineSnapshot(`"type B<T, U> = A"`);
+});

package/dist/UnionType.d.ts

@@ -0,0 +1,13 @@
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare class UnionType<VariantType extends TypeBuilder = TypeBuilder> extends TypeBuilder {
+    needsParenthesisWhenIndexed: boolean;
+    needsParenthesisInKeyof: boolean;
+    readonly variants: VariantType[];
+    constructor(firstType: VariantType);
+    addVariant(variant: VariantType): this;
+    addVariants(variants: VariantType[]): this;
+    write(writer: Writer): void;
+    mapVariants<NewVariantType extends TypeBuilder>(callback: (type: VariantType) => NewVariantType): UnionType<NewVariantType>;
+}
+export declare function unionType<VariantType extends TypeBuilder = TypeBuilder>(types: VariantType[] | VariantType): UnionType<VariantType>;

package/dist/UnionType.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 UnionType_exports = {};
+__export(UnionType_exports, {
+  UnionType: () => UnionType,
+  unionType: () => unionType
+});
+module.exports = __toCommonJS(UnionType_exports);
+var import_TypeBuilder = require("./TypeBuilder");
+class UnionType extends import_TypeBuilder.TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  variants;
+  constructor(firstType) {
+    super();
+    this.variants = [firstType];
+  }
+  addVariant(variant) {
+    this.variants.push(variant);
+    return this;
+  }
+  addVariants(variants) {
+    for (const variant of variants) {
+      this.addVariant(variant);
+    }
+    return this;
+  }
+  write(writer) {
+    writer.writeJoined(" | ", this.variants, (variant, writer2) => {
+      if (variant.needsParenthesisInUnion) {
+        writer2.write("(").write(variant).write(")");
+      } else {
+        writer2.write(variant);
+      }
+    });
+  }
+  mapVariants(callback) {
+    return unionType(this.variants.map((v) => callback(v)));
+  }
+}
+function unionType(types) {
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      throw new TypeError("Union types array can not be empty");
+    }
+    const union = new UnionType(types[0]);
+    for (let i = 1; i < types.length; i++) {
+      union.addVariant(types[i]);
+    }
+    return union;
+  }
+  return new UnionType(types);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnionType,
+  unionType
+});

package/dist/UnionType.mjs

@@ -0,0 +1,49 @@
+import { TypeBuilder } from "./TypeBuilder";
+class UnionType extends TypeBuilder {
+  needsParenthesisWhenIndexed = true;
+  needsParenthesisInKeyof = true;
+  variants;
+  constructor(firstType) {
+    super();
+    this.variants = [firstType];
+  }
+  addVariant(variant) {
+    this.variants.push(variant);
+    return this;
+  }
+  addVariants(variants) {
+    for (const variant of variants) {
+      this.addVariant(variant);
+    }
+    return this;
+  }
+  write(writer) {
+    writer.writeJoined(" | ", this.variants, (variant, writer2) => {
+      if (variant.needsParenthesisInUnion) {
+        writer2.write("(").write(variant).write(")");
+      } else {
+        writer2.write(variant);
+      }
+    });
+  }
+  mapVariants(callback) {
+    return unionType(this.variants.map((v) => callback(v)));
+  }
+}
+function unionType(types) {
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      throw new TypeError("Union types array can not be empty");
+    }
+    const union = new UnionType(types[0]);
+    for (let i = 1; i < types.length; i++) {
+      union.addVariant(types[i]);
+    }
+    return union;
+  }
+  return new UnionType(types);
+}
+export {
+  UnionType,
+  unionType
+};

package/dist/UnionType.test.d.ts

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

package/dist/UnionType.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_NamedType = require("./NamedType");
+var import_stringify = require("./stringify");
+var import_UnionType = require("./UnionType");
+const A = (0, import_NamedType.namedType)("A");
+const B = (0, import_NamedType.namedType)("B");
+(0, import_vitest.test)("one type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_UnionType.unionType)(A))).toMatchInlineSnapshot(`"A"`);
+});
+(0, import_vitest.test)("multiple types", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_UnionType.unionType)(A).addVariant(B))).toMatchInlineSnapshot(`"A | B"`);
+});
+(0, import_vitest.test)("from array", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_UnionType.unionType)([A, B]))).toMatchInlineSnapshot(`"A | B"`);
+});
+(0, import_vitest.test)("with function type", () => {
+  (0, import_vitest.expect)((0, import_stringify.stringify)((0, import_UnionType.unionType)([A, B, (0, import_FunctionType.functionType)()]))).toMatchInlineSnapshot(`"A | B | (() => void)"`);
+});
+(0, import_vitest.test)("fails with empty array", () => {
+  (0, import_vitest.expect)(() => (0, import_UnionType.unionType)([])).toThrowErrorMatchingInlineSnapshot(`[TypeError: Union types array can not be empty]`);
+});
+(0, import_vitest.test)("mapVariants", () => {
+  const union = (0, import_UnionType.unionType)([A, B]).mapVariants(import_ArrayType.array);
+  (0, import_vitest.expect)((0, import_stringify.stringify)(union)).toMatchInlineSnapshot(`"A[] | B[]"`);
+});

package/dist/UnionType.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { array } from "./ArrayType";
+import { functionType } from "./FunctionType";
+import { namedType } from "./NamedType";
+import { stringify } from "./stringify";
+import { unionType } from "./UnionType";
+const A = namedType("A");
+const B = namedType("B");
+test("one type", () => {
+  expect(stringify(unionType(A))).toMatchInlineSnapshot(`"A"`);
+});
+test("multiple types", () => {
+  expect(stringify(unionType(A).addVariant(B))).toMatchInlineSnapshot(`"A | B"`);
+});
+test("from array", () => {
+  expect(stringify(unionType([A, B]))).toMatchInlineSnapshot(`"A | B"`);
+});
+test("with function type", () => {
+  expect(stringify(unionType([A, B, functionType()]))).toMatchInlineSnapshot(`"A | B | (() => void)"`);
+});
+test("fails with empty array", () => {
+  expect(() => unionType([])).toThrowErrorMatchingInlineSnapshot(`[TypeError: Union types array can not be empty]`);
+});
+test("mapVariants", () => {
+  const union = unionType([A, B]).mapVariants(array);
+  expect(stringify(union)).toMatchInlineSnapshot(`"A[] | B[]"`);
+});

package/dist/ValueBuilder.d.ts

@@ -0,0 +1,12 @@
+import { BasicBuilder } from './BasicBuilder';
+import { TypeBuilder } from './TypeBuilder';
+import { Writer } from './Writer';
+export declare abstract class ValueBuilder implements BasicBuilder {
+    as(type: TypeBuilder): TypeAssertion;
+    abstract write(writer: Writer<undefined>): void;
+}
+export declare class TypeAssertion extends ValueBuilder {
+    #private;
+    constructor(value: ValueBuilder, type: TypeBuilder);
+    write(writer: Writer): void;
+}

package/dist/ValueBuilder.js

@@ -0,0 +1,46 @@
+"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 ValueBuilder_exports = {};
+__export(ValueBuilder_exports, {
+  TypeAssertion: () => TypeAssertion,
+  ValueBuilder: () => ValueBuilder
+});
+module.exports = __toCommonJS(ValueBuilder_exports);
+class ValueBuilder {
+  as(type) {
+    return new TypeAssertion(this, type);
+  }
+}
+class TypeAssertion extends ValueBuilder {
+  #value;
+  #type;
+  constructor(value, type) {
+    super();
+    this.#value = value;
+    this.#type = type;
+  }
+  write(writer) {
+    writer.write(this.#value).write(" as ").write(this.#type);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeAssertion,
+  ValueBuilder
+});

package/dist/ValueBuilder.mjs

@@ -0,0 +1,21 @@
+class ValueBuilder {
+  as(type) {
+    return new TypeAssertion(this, type);
+  }
+}
+class TypeAssertion extends ValueBuilder {
+  #value;
+  #type;
+  constructor(value, type) {
+    super();
+    this.#value = value;
+    this.#type = type;
+  }
+  write(writer) {
+    writer.write(this.#value).write(" as ").write(this.#type);
+  }
+}
+export {
+  TypeAssertion,
+  ValueBuilder
+};

package/dist/WellKnownSymbol.d.ts

@@ -0,0 +1,9 @@
+import { BasicBuilder } from './BasicBuilder';
+import { Writer } from './Writer';
+export declare class WellKnownSymbol implements BasicBuilder {
+    readonly name: string;
+    constructor(name: string);
+    write(writer: Writer<undefined>): void;
+}
+export declare function wellKnownSymbol(name: string): WellKnownSymbol;
+export declare const toStringTag: WellKnownSymbol;

package/dist/WellKnownSymbol.js

@@ -0,0 +1,43 @@
+"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 WellKnownSymbol_exports = {};
+__export(WellKnownSymbol_exports, {
+  WellKnownSymbol: () => WellKnownSymbol,
+  toStringTag: () => toStringTag,
+  wellKnownSymbol: () => wellKnownSymbol
+});
+module.exports = __toCommonJS(WellKnownSymbol_exports);
+class WellKnownSymbol {
+  constructor(name) {
+    this.name = name;
+  }
+  write(writer) {
+    writer.write("Symbol.").write(this.name);
+  }
+}
+function wellKnownSymbol(name) {
+  return new WellKnownSymbol(name);
+}
+const toStringTag = wellKnownSymbol("toStringTag");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WellKnownSymbol,
+  toStringTag,
+  wellKnownSymbol
+});

package/dist/WellKnownSymbol.mjs

@@ -0,0 +1,17 @@
+class WellKnownSymbol {
+  constructor(name) {
+    this.name = name;
+  }
+  write(writer) {
+    writer.write("Symbol.").write(this.name);
+  }
+}
+function wellKnownSymbol(name) {
+  return new WellKnownSymbol(name);
+}
+const toStringTag = wellKnownSymbol("toStringTag");
+export {
+  WellKnownSymbol,
+  toStringTag,
+  wellKnownSymbol
+};

package/dist/Writer.d.ts

@@ -0,0 +1,94 @@
+import type { BasicBuilder } from './BasicBuilder';
+export declare const INDENT_SIZE = 2;
+/**
+ * Helper class for building long multi-line formatted strings from building blocks.
+ * Can use either plain strings or `Builder` objects, that would encapsulate formatting logic.
+ */
+export declare class Writer<ContextType = undefined> {
+    readonly context: ContextType;
+    private lines;
+    private currentLine;
+    private currentIndent;
+    private marginSymbol?;
+    private afterNextNewLineCallback?;
+    constructor(startingIndent: number | undefined, context: ContextType);
+    /**
+     * Adds provided value to the current line. Does not end the line.
+     *
+     * @param value
+     * @returns
+     */
+    write(value: string | BasicBuilder<ContextType>): this;
+    /**
+     * Adds several `values` to the current line, separated by `separator`. Both values and separator
+     * can also be `Builder` instances for more advanced formatting.
+     *
+     * @param separator
+     * @param values
+     * @param writeItem allow to customize how individual item is written
+     * @returns
+     */
+    writeJoined<T extends string | BasicBuilder<ContextType>>(separator: string | BasicBuilder<ContextType>, values: T[], writeItem?: (item: T, writer: this) => void): this;
+    /**
+     * Adds a string to current line, flushes current line and starts a new line.
+     * @param line
+     * @returns
+     */
+    writeLine(line: string | BasicBuilder<ContextType>): this;
+    /**
+     * Flushes current line and starts a new line. New line starts at previously configured indentation level
+     * @returns
+     */
+    newLine(): this;
+    /**
+     * Increases indentation level by 1, calls provided callback and then decreases indentation again.
+     * Could be used for writing indented blocks of text:
+     *
+     * @example
+     * ```ts
+     * writer
+     *   .writeLine('{')
+     *   .withIndent(() => {
+     *      writer.writeLine('foo: 123');
+     *      writer.writeLine('bar: 456');
+     *   })
+     *   .writeLine('}')
+     * ```
+     * @param callback
+     * @returns
+     */
+    withIndent(callback: (writer: this) => void): this;
+    /**
+     * Calls provided callback next time when new line is started.
+     * Callback is called after old line have already been flushed and a new
+     * line have been started. Can be used for adding "between the lines" decorations,
+     * such as underlines.
+     *
+     * @param callback
+     * @returns
+     */
+    afterNextNewline(callback: () => void): this;
+    /**
+     * Increases indentation level of the current line by 1
+     * @returns
+     */
+    indent(): this;
+    /**
+     * Decreases indentation level of the current line by 1, if it is possible
+     * @returns
+     */
+    unindent(): this;
+    /**
+     * Adds a symbol, that will replace the first character of the current line (including indentation)
+     * when it is flushed. Can be used for adding markers to the line.
+     *
+     * Note: if indentation level of the line is 0, it will replace the first actually printed character
+     * of the line. Use with caution.
+     * @param symbol
+     * @returns
+     */
+    addMarginSymbol(symbol: string): this;
+    toString(): string;
+    getCurrentLineLength(): number;
+    private indentedCurrentLine;
+}