@goast/core 0.1.1 → 0.2.1

package/esm/lib/utils/string.utils.js

@@ -1,5 +1,32 @@
-import { EOL } from 'os';
 import { isNullish } from './common.utils';
+export function adjustCasing(a, b) {
+    if (typeof a === 'string') {
+        if (typeof b === 'string') {
+            return b;
+        }
+        else {
+            return Object.assign({ casing: a }, b);
+        }
+    }
+    else if (typeof b === 'string') {
+        return Object.assign(Object.assign({}, a), { casing: b });
+    }
+    else {
+        return Object.assign(Object.assign({}, a), b);
+    }
+}
+export function lowercase(str) {
+    return str.toLowerCase();
+}
+export function uppercase(str) {
+    return str.toUpperCase();
+}
+export function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}
+export function uncapitalize(str) {
+    return (str.charAt(0).toLowerCase() + str.slice(1));
+}
 /**
  * Gets the words from a string. Words are separated by capital letters. Leading numbers are removed. Non-alphanumerical characters are removed and interpreted as word seperators. Multiple uppercase letters are interpreted as one word.
  * @param str The string to get the words from.
@@ -218,111 +245,90 @@ export function toCustomCase(str, options) {
 export function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-export const defaultStringBuilderOptions = {
-    newLine: EOL,
-};
 /**
- * Represents a mutable string of characters.
+ * Removes characters from a string and, if necessary, inserts new characters in their place, returning the spliced string.
+ * @param str The string to splice.
+ * @param start The index at which to start changing the string.
+ * @param deleteCount The number of characters to remove.
+ * @param insert The string to insert.
+ * @returns The spliced string.
  */
-export class StringBuilder {
-    get options() {
-        return this._options;
-    }
-    /**
-     * Initializes a new instance of the StringBuilder class.
-     * @param options The options.
-     */
-    constructor(options) {
-        this._str = '';
-        this._options = Object.assign(Object.assign({}, defaultStringBuilderOptions), options);
-    }
-    /**
-     * Creates a new StringBuilder instance and appends the specified string to it.
-     * @param str The string to append.
-     * @param options The options.
-     * @returns A new StringBuilder instance.
-     */
-    static fromString(str, options) {
-        const builder = new StringBuilder(options);
-        builder.append(str);
-        return builder;
-    }
-    /**
-     * Builds a string using a StringBuilder build action.
-     * @param buildAction The build action to perform on the StringBuilder instance.
-     * @param options The options for the StringBuilder instance.
-     * @returns The built string.
-     */
-    static build(buildAction, options) {
-        const builder = new StringBuilder(options);
-        buildAction(builder);
-        return builder.toString();
-    }
-    /**
-     * Appends one or more strings to the end of the current StringBuilder.
-     * @param value The string(s) to append.
-     * @returns The current StringBuilder.
-     */
-    append(...value) {
-        for (const part of value) {
-            if (!part)
-                continue;
-            if (typeof part === 'string') {
-                this._str += part;
-            }
-            else {
-                part(this);
-            }
-        }
-        return this;
-    }
-    /**
-     * Appends one or more strings to the end of the current StringBuilder, followed by a line terminator.
-     * @param value
-     * @returns
-     */
-    appendLine(...value) {
-        return this.append(...value, this._options.newLine);
-    }
-    /**
-     * Prepends one or more strings to the beginning of the current StringBuilder.
-     * @param value The string(s) to prepend.
-     * @returns The current StringBuilder.
-     */
-    prepend(...value) {
-        for (const part of value.reverse()) {
-            if (isNullish(part))
-                continue;
-            if (typeof part === 'function') {
-                const builder = new StringBuilder(this.options);
-                part(builder);
-                this._str = builder.toString() + this._str;
-            }
-            else if (part.length > 0) {
-                this._str = part + this._str;
-            }
-        }
-        return this;
-    }
-    /**
-     * Prepends one or more strings to the beginning of the current StringBuilder, followed by a line terminator.
-     * @param value The string(s) to prepend.
-     * @returns The current StringBuilder.
-     */
-    prependLine(...value) {
-        return this.prepend(...value, this._options.newLine);
-    }
-    /**
-     * Converts the value of this instance to a string.
-     * @returns A string whose value is the same as this instance.
-     */
-    toString() {
-        return this._str;
-    }
-    /**
-     * Removes all characters from the current StringBuilder.
-     */
-    clear() {
-        this._str = '';
+export function spliceString(str, start, deleteCount, insert) {
+    return str.slice(0, start) + insert + str.slice(start + deleteCount);
+}
+/**
+ * Removes leading indentation based on the last line. Also removes the first line if it is empty.
+ * @param str The string to trim.
+ */
+export function trimIndent(str) {
+    var _a, _b;
+    const indent = (_b = (_a = str.match(/\n( *).*$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
+    if (indent.length === 0)
+        return str;
+    return str.replace(/^\r?\n/, '').replace(new RegExp(`^ {0,${indent.length}}`, 'gm'), '');
+}
+function isNonLineBreakWhitespaceChar(char) {
+    return (char === ' ' ||
+        char === '\t' ||
+        char === '\f' ||
+        char === '\v' ||
+        char === '\u00a0' ||
+        char === '\u1680' ||
+        char === '\u2000' ||
+        char === '\u2001' ||
+        char === '\u2002' ||
+        char === '\u2003' ||
+        char === '\u2004' ||
+        char === '\u2005' ||
+        char === '\u2006' ||
+        char === '\u2007' ||
+        char === '\u2008' ||
+        char === '\u2009' ||
+        char === '\u200a' ||
+        char === '\u2028' ||
+        char === '\u2029' ||
+        char === '\u202f' ||
+        char === '\u205f' ||
+        char === '\u3000' ||
+        char === '\ufeff');
+}
+export function trimEnd(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trimEnd();
+    let i = str.length;
+    for (; isNonLineBreakWhitespaceChar(str[i - 1]); i--)
+        ;
+    return str.substring(0, i);
+}
+export function trimStart(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trimStart();
+    let i = 0;
+    for (; isNonLineBreakWhitespaceChar(str[i]); i++)
+        ;
+    return str.substring(i);
+}
+export function trim(str, includeNewLine = true) {
+    if (includeNewLine)
+        return str.trim();
+    let s = 0;
+    for (; isNonLineBreakWhitespaceChar(str[s]); s++)
+        ;
+    let e = str.length;
+    for (; isNonLineBreakWhitespaceChar(str[e - 1]); e--)
+        ;
+    return str.substring(s, e);
+}
+export function removeStr(str, rem) {
+    let i = str.indexOf(rem);
+    if (i === -1)
+        return str;
+    let result = '';
+    let s = 0;
+    while (i !== -1) {
+        result += str.substring(s, i);
+        s = i + rem.length;
+        i = str.indexOf(rem, s);
     }
+    return result + str.substring(s);
 }

package/esm/lib/utils/type.utils.js

@@ -1 +1,6 @@
-export {};
+export function stringUnionToArray() {
+    return (...elements) => elements;
+}
+export function suggestionsAsString(value) {
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/core",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "repository": "https://github.com/MaSch0212/goast.git",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -9,10 +9,10 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "fs-extra": "^11.1.1",
-    "node-fetch": "^2.6.11",
-    "yaml": "^2.3.1",
-    "tslib": "^2.3.0"
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^2.7.0",
+    "yaml": "^2.4.1",
+    "tslib": "2.6.2"
   },
   "module": "./esm/index.js",
   "main": "./cjs/index.js",

package/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from './lib/ast';
 export * from './lib/codegen';
 export * from './lib/parse';
 export * from './lib/transform';

package/types/lib/ast/index.d.ts

@@ -0,0 +1 @@
+export * from './node';

package/types/lib/ast/node.d.ts

@@ -0,0 +1,14 @@
+import { AppendValue, Prettify, StringBuilder } from '../utils';
+export type AstNodeInject<TBuilder extends StringBuilder, TInjects extends string> = {
+    [K in `${'after' | 'before'}${Capitalize<TInjects>}`]?: AppendValue<TBuilder>;
+};
+export type AstNodeOptions<TBase extends abstract new (...args: any) => any, TExtensions extends object = {}> = Prettify<TExtensions & ConstructorParameters<TBase>[0]>;
+export declare abstract class AstNode<TBuilder extends StringBuilder = StringBuilder, TInjects extends string = never> {
+    inject: AstNodeInject<TBuilder, TInjects | ''>;
+    constructor(options: {
+        inject?: AstNode<TBuilder, TInjects>['inject'];
+    });
+    write(builder: TBuilder): void;
+    protected getParentNode(builder: TBuilder): AstNode | undefined;
+    protected abstract onWrite(builder: TBuilder): void;
+}

package/types/lib/transform/api-types.d.ts

@@ -108,7 +108,9 @@ export type ApiSchemaBase = ApiSchemaComponent & {
     custom: Record<string, unknown>;
     not: ApiSchema | undefined;
     discriminator: ApiSchemaDiscriminator | undefined;
-    inheritedSchemas: ApiSchema[];
+    inheritedSchemas: (ApiSchema & {
+        discriminator: NonNullable<ApiSchema['discriminator']>;
+    })[];
 };
 export type ApiSchema<T extends ApiSchemaKind = ApiSchemaKind> = ApiSchemaBase & ApiSchemaExtensions<T>;
 type AdditionalCombinedSchemaProperties = {

package/types/lib/utils/array.utils.d.ts

@@ -0,0 +1 @@
+export declare function removeItems<T>(array: T[], predicate: (item: T) => boolean): void;

package/types/lib/utils/class.utils.d.ts

@@ -0,0 +1,7 @@
+export declare function classifyArray<TItem, TClassification extends Record<string, abstract new (...args: any[]) => any>>(items: Iterable<TItem>, classification: TClassification): {
+    [P in keyof TClassification]: InstanceType<TClassification[P]>[];
+} & {
+    rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
+};
+export declare function isInstanceOf<T>(item: unknown, type: abstract new (...args: any[]) => T): item is T;
+export declare function getIsInstanceOf<T>(type: abstract new (...args: any[]) => T): (item: unknown) => item is T;

package/types/lib/utils/common.utils.d.ts

@@ -1,3 +1,15 @@
-import { Nullable } from './type.utils';
+import { SingleOrMultiple } from './type.utils';
 export declare function isNullish(value: unknown): value is null | undefined;
-export declare function notNullish<T>(value: Nullable<T>): value is T;
+export declare function notNullish<T>(value: T): value is NonNullable<T>;
+export declare function concatSingleOrMultiple<T>(...values: SingleOrMultiple<T>[]): SingleOrMultiple<T>;
+export declare function isIterable(value: unknown): value is Iterable<unknown>;
+export declare function toArray<T>(value: T | T[] | Iterable<T>): T[];
+export declare function modify<T>(value: T, callback: (value: NonNullable<T>) => void): T;
+export declare function run<T>(value: T, callback: (value: T) => void): T;
+export declare function transform<T, U>(value: T, callback: (value: T) => U): U;
+type IterableItem<T> = T extends Iterable<infer U> ? U : never;
+export declare function modifyEach<T extends Iterable<unknown>>(values: T, callback: (value: NonNullable<IterableItem<T>>) => void): T;
+export declare function runEach<T extends Iterable<unknown>>(values: T, callback: (value: IterableItem<T>) => void): T;
+export declare function transformEach<T, U>(values: Iterable<T>, callback: (value: T) => U): U[];
+export declare function asVoid(_: unknown): void;
+export {};

package/types/lib/utils/error.utils.d.ts

@@ -0,0 +1 @@
+export declare function throwExp(message: string): never;

package/types/lib/utils/index.d.ts

@@ -1,10 +1,14 @@
+export * from './array.utils';
+export * from './class.utils';
 export * from './common.utils';
 export * from './endpoint.utils';
+export * from './error.utils';
 export * from './factory';
 export * from './generator.utils';
 export * from './object.utils';
 export * from './schema.utils';
 export * from './source-builder';
+export * from './string-builder';
 export * from './string.utils';
 export * from './string.utils.types';
 export * from './type.utils';

package/types/lib/utils/object.utils.d.ts

@@ -1 +1 @@
-export declare function createOverwriteProxy<T extends object>(target: T): T;
+export declare function createOverwriteProxy<T extends object>(target: T, values?: Partial<T>): T;

package/types/lib/utils/source-builder.d.ts

@@ -1,5 +1,6 @@
 import { Condition } from './condition';
-import { BuilderFn, StringBuilder, StringBuilderOptions, TextOrBuilderFn } from './string.utils';
+import { AppendParam, AppendValue, StringBuilder, StringBuilderOptions } from './string-builder';
+import { BuilderFn } from './string-builder/string-builder';
 import { Nullable } from './type.utils';
 export type IndentOptions = {
     readonly type: 'tabs';
@@ -9,13 +10,12 @@ export type IndentOptions = {
 };
 export type SourceBuilderOptions = StringBuilderOptions & {
     indent: IndentOptions;
-    charsTreatedAsEmptyLine: string[];
 };
 export declare const defaultSourceBuilderOptions: SourceBuilderOptions;
 type KnownParatheses = '()' | '[]' | '{}' | '<>';
-export type Paratheses = KnownParatheses | Omit<string, KnownParatheses> | [open: Nullable<string>, close: Nullable<string>];
-export type SeparatorBuidlerFn<TBuilder extends SourceBuilder, TItem> = (builder: TBuilder, previousItem: TItem, nextItem: TItem, previousItemIndex: number, nextItemIndex: number) => void;
-export type Separator<TBuilder extends SourceBuilder, TItem> = string | SeparatorBuidlerFn<TBuilder, TItem>;
+export type Paratheses<TBuilder extends StringBuilder> = KnownParatheses | Omit<string, KnownParatheses> | [open: Nullable<AppendValue<TBuilder>>, close: Nullable<AppendValue<TBuilder>>];
+export type SeparatorBuidlerFn<TBuilder, TItem> = (builder: TBuilder, previousItem: TItem, nextItem: TItem, previousItemIndex: number, nextItemIndex: number) => void;
+export type Separator<TBuilder, TItem> = string | SeparatorBuidlerFn<TBuilder, TItem>;
 /**
  * Options for the `parenthesize` methods of the `SourceBuilder`.
  * @see SourceBuilder.parenthesize
@@ -23,20 +23,28 @@ export type Separator<TBuilder extends SourceBuilder, TItem> = string | Separato
  */
 export type ParenthesizeOptions = {
     /**
-     * Whether to add line breaks after start and before end of the parentheses. Defaults to `false`.
+     * Whether to add line breaks after start and before end of the parentheses.
+     * @default false
      */
     readonly multiline?: boolean;
     /**
-     * Whether to indent the content inside parentheses. Defaults to `true`.
+     * Whether to indent the content inside parentheses.
+     * @default true
      */
     readonly indent?: boolean;
+    /**
+     * Whether to pretend that the current line and the one before is empty or consists only of whitespace characters.
+     * This is useful when the parentheses are used as a block and `ensurePreviousLineEmpty` is used.
+     * @default true
+     */
+    readonly pretendEmpty?: boolean;
 };
 /**
  * Options for the `forEach` methods of the `SourceBuilder`.
  * @see SourceBuilder.forEach
  * @see SourceBuilder.forEachIf
  */
-export type ForEachOptions<TBuilder extends SourceBuilder, TItem> = {
+export type ForEachOptions<TBuilder, TItem> = {
     /**
      * The condition to check before adding content for each item. Defaults to `true`.
      */
@@ -46,21 +54,20 @@ export type ForEachOptions<TBuilder extends SourceBuilder, TItem> = {
      */
     readonly separator?: Separator<TBuilder, TItem>;
 };
+type SwitchCase<TValue, TBuilder extends StringBuilder> = {
+    case: TValue;
+    value: AppendValue<TBuilder>;
+};
 /**
  * Represents an in-memory source file.
  */
-export declare class SourceBuilder extends StringBuilder {
+export declare class SourceBuilder<TAdditionalAppends = never> extends StringBuilder<TAdditionalAppends> {
     private readonly __options;
-    private readonly _emptyLineCharRegex;
     private readonly _indentString;
-    private _linePrefix;
     private _isLineIndented;
     private _isLastLineEmpty;
     private _isCurrentLineEmpty;
-    /**
-     * Gets or sets the current indentation level.
-     */
-    currentIndentLevel: number;
+    private _linePrefixNodes;
     /**
      * Gets the options used by this instance.
      */
@@ -83,63 +90,58 @@ export declare class SourceBuilder extends StringBuilder {
      * @param options The options to use for the `SourceBuilder` instance.
      * @returns The string built by the `SourceBuilder` instance.
      */
-    static build(buildAction: BuilderFn<SourceBuilder>, options?: Partial<SourceBuilderOptions>): string;
-    /**
-     * Appends one or more strings to the end of the current SourceBuilder.
-     * @param value The string(s) to append.
-     * @returns The current SourceBuilder.
-     */
-    append(...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    static build(buildAction: AppendParam<SourceBuilder, never>, options?: Partial<SourceBuilderOptions>): string;
+    protected appendSingle(value: AppendParam<this, TAdditionalAppends>): void;
     /**
      * Appends one or more strings to the end of the current SourceBuilder if the specified condition is true.
      * @param condition The condition to check before appending the specified value.
      * @param value The string(s) to append.
      * @returns The current SourceBuilder.
      */
-    appendIf(condition: Condition, ...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendIf(condition: Condition, ...value: AppendParam<this, TAdditionalAppends>[]): this;
     /**
      * Appends one or more strings to the end of the current SourceBuilder, followed by a line terminator.
      * @param value The string(s) to append.
      * @returns The current SourceBuilder.
      */
-    appendLine(...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendLine(...value: AppendParam<this, TAdditionalAppends>[]): this;
     /**
      * Appends one or more strings to the end of the current SourceBuilder, followed by a line terminator, if the specified condition is true.
      * @param condition The condition to check before appending the specified value.
      * @param value The string(s) to append.
      * @returns The current SourceBuilder.
      */
-    appendLineIf(condition: Condition, ...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendLineIf(condition: Condition, ...value: AppendParam<this, TAdditionalAppends>[]): this;
     /**
      * Appends the specified values to this source builder with the specified line prefix.
      * @param {string} prefix - The line prefix to use.
      * @param {...(string|null|undefined)} value - The values to append.
      * @returns {SourceBuilder} This source builder instance.
      */
-    appendWithLinePrefix(prefix: string, ...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendWithLinePrefix(prefix: string, ...value: AppendParam<this, TAdditionalAppends>[]): this;
     /**
      * Appends the specified values to this source builder as a new line with the specified line prefix.
      * @param {string} prefix - The line prefix to use.
      * @param {...(string|null|undefined)} value - The values to append.
      * @returns {SourceBuilder} This source builder instance.
      */
-    appendLineWithLinePrefix(prefix: string, ...value: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendLineWithLinePrefix(prefix: string, ...value: AppendParam<this, TAdditionalAppends>[]): this;
     /**
      * Prepends one or more strings to the beginning of the current SourceBuilder if the specified condition is true.
      * @param condition The condition to check before prepending the specified value.
      * @param value The string(s) to prepend.
      * @returns The current SourceBuilder.
      */
-    prependIf(condition: Condition, ...value: Nullable<TextOrBuilderFn<StringBuilder>>[]): this;
+    prependIf(condition: Condition, ...value: AppendParam<StringBuilder, never>[]): this;
     /**
      * Prepends one or more strings to the beginning of the current SourceBuilder, followed by a line terminator, if the specified condition is true.
      * @param condition The condition to check before appending the specified value.
      * @param value The string(s) to prepend.
      * @returns The current SourceBuilder.
      */
-    prependLineIf(condition: Condition, ...value: Nullable<TextOrBuilderFn<StringBuilder>>[]): this;
+    prependLineIf(condition: Condition, ...value: AppendParam<StringBuilder, never>[]): this;
     /**
-     * Ensures that the current line is empty or consists only of whitespace characters.
+     * Ensures that the current line and the one before is empty or consists only of whitespace characters.
      * @returns A reference to this instance.
      */
     ensurePreviousLineEmpty(): this;
@@ -148,6 +150,16 @@ export declare class SourceBuilder extends StringBuilder {
      * @returns A reference to this instance.
      */
     ensureCurrentLineEmpty(): this;
+    /**
+     * Pretends that the current line and the one before is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    pretendPreviousLineEmpty(): this;
+    /**
+     * Pretends that the current line is empty or consists only of whitespace characters.
+     * @returns A reference to this instance.
+     */
+    pretendCurrentLineEmpty(): this;
     /**
      * Inserts specified content if the specified condition is true.
      * @param condition The condition to check before inserting content.
@@ -155,21 +167,23 @@ export declare class SourceBuilder extends StringBuilder {
      * @param elseBuilderFn The function to add content if the condition is false.
      * @returns A reference to this instance.
      */
-    if(condition: Condition, builderFn: BuilderFn<this>, elseBuilderFn?: BuilderFn<this>): this;
+    if(condition: Condition, builderFn: AppendParam<this, TAdditionalAppends>, elseBuilderFn?: AppendParam<this, TAdditionalAppends>): this;
+    switch<T extends string | number>(value: T, cases: Record<T, AppendParam<this, TAdditionalAppends>>, defaultBuilderFn?: AppendParam<this, TAdditionalAppends>): this;
+    switch<T>(value: T, cases: SwitchCase<T, this>[], defaultBuilderFn?: AppendParam<this, TAdditionalAppends>, equals?: (a: T, b: T) => boolean): this;
     /**
      * Adds one indentation level. If the current line already contains characters, only subsequent lines are affected.
      * @param builderFn The function to add indented content or the content itself.
      * @param condition The condition to check before adding indentation.
      * @returns A reference to this instance.
      */
-    indent(value: Nullable<TextOrBuilderFn<this>>): this;
+    indent(value: AppendParam<this, TAdditionalAppends>): this;
     /**
      * Adds one indentation level if the specified condition is true. If the current line already contains characters, only subsequent lines are affected.
      * @param builderFn The function to add indented content or the content itself.
      * @param condition The condition to check before adding indentation.
      * @returns A reference to this instance.
      */
-    indentIf(condition: Condition, value: Nullable<TextOrBuilderFn<this>>): this;
+    indentIf(condition: Condition, value: AppendParam<this, TAdditionalAppends>): this;
     /**
      * Adds parentheses around the specified content.
      * @param brackets The brackets to use.
@@ -177,7 +191,7 @@ export declare class SourceBuilder extends StringBuilder {
      * @param options Options for the parentheses.
      * @returns A reference to this instance.
      */
-    parenthesize(brackets: Paratheses, value: Nullable<TextOrBuilderFn<this>>, options?: ParenthesizeOptions): this;
+    parenthesize(brackets: Paratheses<this>, value: AppendParam<this, TAdditionalAppends>, options?: ParenthesizeOptions): this;
     /**
      * Adds parentheses around the specified content if the specified condition is true.
      * @param condition The condition to check before adding parentheses.
@@ -186,7 +200,7 @@ export declare class SourceBuilder extends StringBuilder {
      * @param options Options for the parentheses.
      * @returns A reference to this instance.
      */
-    parenthesizeIf(condition: Condition, brackets: Paratheses, value: TextOrBuilderFn<this>, options?: ParenthesizeOptions): this;
+    parenthesizeIf(condition: Condition, brackets: Paratheses<this>, value: AppendParam<this, TAdditionalAppends>, options?: ParenthesizeOptions): this;
     /**
      * Adds content for each item in the specified array.
      * @param items The items to add content for.
@@ -196,8 +210,12 @@ export declare class SourceBuilder extends StringBuilder {
      */
     forEach<T>(items: Iterable<T>, builderFn: (builder: this, item: T, index: number) => void, options?: ForEachOptions<this, T>): this;
     forEachIf<T>(condition: Condition, items: Iterable<T>, builderFn: (builder: this, item: T, index: number) => void, options?: ForEachOptions<this, T>): this;
-    appendSeparated(items: Iterable<Nullable<TextOrBuilderFn<this>>>, separator: string): this;
-    appendSeparatedIf(condition: Condition, items: Iterable<Nullable<TextOrBuilderFn<this>>>, separator: string): this;
+    appendSeparated(items: Iterable<AppendParam<this, TAdditionalAppends>>, separator: string): this;
+    appendSeparatedIf(condition: Condition, items: Iterable<AppendParam<this, TAdditionalAppends>>, separator: string): this;
     private appendIndent;
 }
+declare function _builderTemplate<T extends SourceBuilder>(template: readonly string[] | ArrayLike<string>, ...substitutions: AppendValue<T>[]): BuilderFn<T>;
+export declare const builderTemplate: typeof _builderTemplate & {
+    indent: <T extends SourceBuilder<never>>(template: readonly string[] | ArrayLike<string>, ...substitutions: AppendValue<T>[]) => BuilderFn<T>;
+};
 export {};

package/types/lib/utils/string-builder/index.d.ts

@@ -0,0 +1,3 @@
+export * from './options';
+export { AppendParam, StringBuilder } from './string-builder';
+export * from './utils';

package/types/lib/utils/string-builder/options.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Options for the StringBuilder class.
+ * @default newLine = os.EOL
+ */
+export type StringBuilderOptions = {
+    readonly newLine: string;
+};
+export declare const defaultStringBuilderOptions: StringBuilderOptions;