@satisfactory-dev/docs.json.ts 0.6.1

package/lib/DocsTsGenerator.js

@@ -0,0 +1,188 @@
+import { readFile, writeFile, } from 'node:fs/promises';
+import { basename, dirname, } from 'node:path';
+import { existsSync, } from 'node:fs';
+import { fileURLToPath, } from 'node:url';
+import * as prettier from 'prettier';
+import standalone from 'ajv/dist/standalone';
+import { ESLint, } from 'eslint';
+import update8_schema from '../schema/update8.schema.json' assert {
+    type: 'json'
+};
+import { createHash, } from 'node:crypto';
+import { is_non_empty_array, object_has_only_properties_that_match_predicate, object_has_property, property_exists_on_object, value_is_non_array_object, } from './CustomParsingTypes/CustomPairingTypes';
+import { is_string, } from './StringStartsWith';
+import { NoMatchError, } from './Exceptions';
+import { TypedString, } from './CustomParsingTypes/TypedString';
+import { compile, esmify, } from './AjvUtilities';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class ValidationError extends Error {
+    errors;
+    json;
+    constructor(message, errors, json) {
+        super(message);
+        this.errors = errors || [];
+        this.json = json;
+    }
+}
+export class DocsTsGenerator {
+    docs;
+    cache_path;
+    docs_path;
+    ajv;
+    static PERF_EARLY_RETURN = 'Early Return of Docs.json';
+    static PERF_FAILURE = 'Failure to load Docs.json';
+    static PERF_FILE_PARSED = 'Docs.json contents parsed';
+    static PERF_FILE_READ = 'Docs.json contents read';
+    static PERF_START_LOADING_JSON = 'Start Loading Docs.json';
+    static PERF_VALIDATION_COMPILED = 'Docs.json validation compiled';
+    static PERF_VALIDATION_FINISHED = 'Docs.json validation finished';
+    static PERF_VALIDATION_PRECOMPILE = 'Docs.json validation pre-compilation started';
+    static PERF_VALIDATION_STARTED = 'Docs.json validation started';
+    constructor({ 
+    // Ajv instance
+    ajv, 
+    // raw JSON or path to UTF-16LE encoded Docs.json
+    docs_path, 
+    // optional cache folder path for cacheable resources
+    cache_path = undefined, }) {
+        this.ajv = ajv;
+        this.docs_path = docs_path;
+        this.cache_path = cache_path;
+    }
+    async definition($ref) {
+        const schema = await this.schema();
+        if (!property_exists_on_object(schema.$defs, $ref)) {
+            throw new NoMatchError({
+                $ref,
+                options: Object.keys(schema.$defs),
+            });
+        }
+        return schema.$defs[$ref];
+    }
+    async get() {
+        return this.validate(await this.load(), await this.schema());
+    }
+    async schema() {
+        await this.validate_schema(update8_schema);
+        return update8_schema;
+    }
+    async load() {
+        if (undefined === this.docs) {
+            performance.mark(DocsTsGenerator.PERF_START_LOADING_JSON);
+            if ('string' !== typeof this.docs_path) {
+                performance.measure(DocsTsGenerator.PERF_EARLY_RETURN, DocsTsGenerator.PERF_START_LOADING_JSON);
+                return this.docs_path;
+            }
+            else if (!this.docs_path.endsWith('.json')) {
+                performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
+                throw new Error('Probably not a JSON file');
+            }
+            else {
+                let maybe_json;
+                try {
+                    if (this.cache_path) {
+                        const utf8_filename = basename(this.docs_path).replace(/\.json$/, '.utf8.json');
+                        const utf8_filepath = `${this.cache_path}/${utf8_filename}`;
+                        if (existsSync(utf8_filepath)) {
+                            const file_contents = await readFile(utf8_filepath);
+                            performance.measure(DocsTsGenerator.PERF_FILE_READ, DocsTsGenerator.PERF_START_LOADING_JSON);
+                            maybe_json = JSON.parse(file_contents.toString());
+                            performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
+                        }
+                        else {
+                            maybe_json = await this.load_from_file(this.docs_path);
+                            performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
+                            await writeFile(utf8_filepath, JSON.stringify(maybe_json, null, '\t') + '\n');
+                        }
+                    }
+                    else {
+                        maybe_json = await this.load_from_file(this.docs_path);
+                        performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
+                    }
+                }
+                catch (err) {
+                    performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
+                    throw err;
+                }
+                if (!is_non_empty_array(maybe_json, value_is_non_array_object)) {
+                    performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
+                    throw new Error('Was expecting json to be an array!');
+                }
+                this.docs = maybe_json;
+            }
+            if (undefined === this.docs) {
+                throw new Error('this.docs not set!');
+            }
+        }
+        return this.docs;
+    }
+    async load_from_file(filepath) {
+        const file = await readFile(filepath, {
+            encoding: 'utf-16le',
+        });
+        performance.measure(DocsTsGenerator.PERF_FILE_READ, DocsTsGenerator.PERF_START_LOADING_JSON);
+        const utf8 = Buffer.from(file).toString('utf-8');
+        return JSON.parse(utf8.trim());
+    }
+    async validate(json, schema) {
+        performance.mark(DocsTsGenerator.PERF_VALIDATION_STARTED);
+        const validateDocs = await this.validate_schema(schema);
+        performance.measure(DocsTsGenerator.PERF_VALIDATION_COMPILED, DocsTsGenerator.PERF_VALIDATION_STARTED);
+        const result = validateDocs(json);
+        performance.measure(DocsTsGenerator.PERF_VALIDATION_FINISHED, DocsTsGenerator.PERF_VALIDATION_STARTED);
+        if (!result) {
+            throw new ValidationError('Failed to validate against the provided JSON Schema', validateDocs.errors, json);
+        }
+        return json;
+    }
+    async validate_schema(schema) {
+        if (object_has_property(schema, '$defs', value_is_non_array_object)
+            && object_has_only_properties_that_match_predicate(schema.$defs, value_is_non_array_object)) {
+            const { $defs } = schema;
+            if (object_has_only_properties_that_match_predicate($defs, value_is_non_array_object)) {
+                TypedString.instance().configure_ajv($defs, this.ajv);
+            }
+        }
+        if (this.cache_path) {
+            const file_sha512 = createHash('sha512');
+            if (!object_has_property(schema, '$id', is_string)) {
+                throw new ValidationError('Schema does not have an id!', undefined, schema);
+            }
+            file_sha512.update(await readFile(`${__dirname}/../schema/${schema['$id']}`));
+            const filename = `${schema['$id']}.${file_sha512.digest('hex')}.mjs`;
+            const filepath = `${this.cache_path}/${filename}`;
+            if (!existsSync(filepath)) {
+                performance.mark(DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
+                performance.measure('ajv configured', DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
+                await writeFile(filepath, esmify(standalone(this.ajv, compile(this.ajv, schema))));
+                performance.measure('ajv pre-compilation done', DocsTsGenerator.PERF_VALIDATION_PRECOMPILE, DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
+            }
+            const { default: validateDocs, } = (await import(filepath));
+            return validateDocs;
+        }
+        return compile(this.ajv, schema);
+    }
+}
+const prettier_config = prettier.resolveConfig(`${__dirname}/../.prettierrc`);
+export async function format_code(code, parser = 'typescript') {
+    const config = await prettier_config;
+    if (!config) {
+        throw new Error('could not find prettier config');
+    }
+    code = await prettier.format(code, Object.assign({
+        parser,
+    }, config));
+    return code.replace(/(\t+) +/gm, '$1');
+}
+export async function eslint_generated_types(parent_folder) {
+    const eslint = new ESLint({
+        fix: true,
+        cache: true,
+        cacheLocation: `${parent_folder}/.eslintcache`,
+        cacheStrategy: 'content',
+    });
+    const eslint_formatter = eslint.loadFormatter('stylish');
+    const results = await eslint.lintFiles(`${parent_folder}/**/*.ts`);
+    process.stdout.write(`${await (await eslint_formatter).format(results)}\n`);
+}
+//# sourceMappingURL=DocsTsGenerator.js.map

package/lib/DocsValidation.d.ts

@@ -0,0 +1,7 @@
+import Ajv from 'ajv/dist/2020';
+export declare function string_to_native_type(data: string, shallow?: boolean): object | unknown[] | string | false;
+export declare function string_to_object<T extends {
+    [key: string]: unknown;
+}>(data: string, shallow?: boolean): T | false;
+export declare function string_to_array<T extends unknown[]>(data: string, shallow?: boolean): T | false;
+export declare function configure_ajv(ajv: Ajv): void;

package/lib/DocsValidation.js

@@ -0,0 +1,179 @@
+import { _, } from 'ajv/dist/2020';
+import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
+import { is_string, } from './StringStartsWith';
+export function string_to_native_type(data, shallow = false) {
+    data = data.trim();
+    if (/^\(.+\)$/.test(data)) {
+        const object = string_to_object(data, shallow);
+        return false !== object ? object : string_to_array(data, shallow);
+    }
+    else if (/^".+"$/.test(data)) {
+        return data.substring(1, data.length - 1);
+    }
+    return data;
+}
+export function string_to_object(data, shallow = false) {
+    if ('' === data) {
+        return false;
+    }
+    const match = /^\([^=]+=([^,]+|\([^)]+\))(,[^=]+=(\([^)]+)\)|,[^=]+=[^,]+)*\)$/
+        .test(data);
+    if (!match) {
+        return false;
+    }
+    return Object.fromEntries(data
+        .substring(1, data.length - 1)
+        .split('')
+        .reduce((was, is, index, array) => {
+        let add_buffer = false;
+        if ('key' === was.mode && '=' !== is) {
+            add_buffer = true;
+        }
+        else if ('key' === was.mode && '=' === is) {
+            was.mode = 'value';
+            was.current_value_nesting = 0;
+            add_buffer = false;
+        }
+        else if ('value' === was.mode) {
+            add_buffer = true;
+            if ('(' === is) {
+                ++was.current_value_nesting;
+            }
+            else if (')' === is) {
+                --was.current_value_nesting;
+            }
+            else if (',' === is
+                && 0 === was.current_value_nesting) {
+                if (/^".+"$/.test(was.current_value_buffer)) {
+                    was.current_value_buffer =
+                        was.current_value_buffer.substring(1, was.current_value_buffer.length - 1);
+                }
+                const coerced_value = shallow
+                    ? was.current_value_buffer
+                    : string_to_native_type(was.current_value_buffer);
+                was.properties.push([
+                    was.current_key_buffer,
+                    false !== coerced_value
+                        ? coerced_value
+                        : was.current_value_buffer,
+                ]);
+                was.mode = 'key';
+                was.current_key_buffer = '';
+                was.current_value_buffer = '';
+                add_buffer = false;
+            }
+        }
+        if (add_buffer) {
+            if ('key' === was.mode) {
+                was.current_key_buffer += is;
+            }
+            else {
+                was.current_value_buffer += is;
+            }
+        }
+        if (index === array.length - 1) {
+            if ('' !== was.current_key_buffer) {
+                const coerced_value = shallow
+                    ? (/^".+"$/.test(was.current_value_buffer)
+                        ? was.current_value_buffer.substring(1, was.current_value_buffer.length - 1)
+                        : was.current_value_buffer)
+                    : string_to_native_type(was.current_value_buffer);
+                was.properties.push([
+                    was.current_key_buffer,
+                    false !== coerced_value
+                        ? coerced_value
+                        : was.current_value_buffer,
+                ]);
+            }
+            was.current_key_buffer = '';
+            was.current_value_buffer = '';
+            was.current_value_nesting = 0;
+        }
+        return was;
+    }, {
+        properties: [],
+        mode: 'key',
+        current_key_buffer: '',
+        current_value_buffer: '',
+        current_value_nesting: 0,
+    }).properties);
+}
+export function string_to_array(data, shallow = false) {
+    if (!/^\(.+\)$/.test(data)) {
+        return false;
+    }
+    return data
+        .substring(1, data.length - 1)
+        .split('')
+        .reduce((was, is, index, array) => {
+        let add_buffer = true;
+        let add_value = false;
+        if (',' === is && 0 === was.current_value_nesting) {
+            add_buffer = false;
+            add_value = true;
+        }
+        if ('(' === is) {
+            ++was.current_value_nesting;
+        }
+        else if (')' === is) {
+            --was.current_value_nesting;
+        }
+        if (add_buffer) {
+            was.current_item_buffer += is;
+        }
+        if (add_value
+            || (index === array.length - 1
+                && '' !== was.current_item_buffer)) {
+            if (/^".+"$/.test(was.current_item_buffer)) {
+                was.values.push(was.current_item_buffer.substring(1, was.current_item_buffer.length - 1));
+                was.current_item_buffer = '';
+            }
+            else {
+                const coerced_value = shallow
+                    ? was.current_item_buffer.trim()
+                    : string_to_native_type(was.current_item_buffer);
+                was.values.push(false !== coerced_value
+                    ? coerced_value
+                    : was.current_item_buffer.trim());
+                was.current_item_buffer = '';
+            }
+        }
+        if (index === array.length - 1) {
+            was.current_item_buffer = '';
+            was.current_value_nesting = 0;
+        }
+        return was;
+    }, {
+        values: [],
+        current_item_buffer: '',
+        current_value_nesting: 0,
+    }).values;
+}
+const already_configured = new WeakSet();
+export function configure_ajv(ajv) {
+    if (already_configured.has(ajv)) {
+        return;
+    }
+    already_configured.add(ajv);
+    UnrealEngineString.configure_ajv(ajv);
+    ajv.addKeyword({
+        keyword: 'string_starts_with',
+        type: 'string',
+        metaSchema: {
+            type: 'string',
+            minLength: 1,
+        },
+        compile: (value) => {
+            return (data) => data.startsWith(value);
+        },
+        code: (ctx) => {
+            const schema = ctx?.schema;
+            if (!is_string(schema)) {
+                throw new Error(`ctx.schema was not a string, ${typeof schema} found!`);
+            }
+            const { data } = ctx;
+            ctx.pass(_ `${data}.startsWith(${schema})`);
+        },
+    });
+}
+//# sourceMappingURL=DocsValidation.js.map

package/lib/Exceptions.d.ts

@@ -0,0 +1,7 @@
+export declare class NoMatchError<T = unknown> extends Error {
+    readonly property: T;
+    constructor(property: T, message?: string);
+}
+export declare class FragileTypeSafetyError extends NoMatchError {
+    constructor(property: unknown);
+}

package/lib/Exceptions.js

@@ -0,0 +1,13 @@
+export class NoMatchError extends Error {
+    property;
+    constructor(property, message = 'No match found!') {
+        super(message);
+        this.property = property;
+    }
+}
+export class FragileTypeSafetyError extends NoMatchError {
+    constructor(property) {
+        super(property, 'type safety in here is a bit fragile, check earlier in the stack');
+    }
+}
+//# sourceMappingURL=Exceptions.js.map

package/lib/FilesGenerator.d.ts

@@ -0,0 +1,19 @@
+import { Node } from 'typescript';
+export type entry = {
+    file: string;
+    node: Node;
+};
+export declare abstract class FilesGenerator {
+    abstract generate_files(): AsyncGenerator<entry>;
+    static merge_files(generators: FilesGenerator[], onto?: {
+        [key: string]: Node[];
+    } | undefined): Promise<{
+        [key: string]: Node[];
+    }>;
+}
+export declare class FromArray extends FilesGenerator {
+    private readonly entries;
+    constructor(entries: [entry, ...entry[]]);
+    generate_files(): AsyncGenerator<entry, void, undefined>;
+}
+export declare function guess_filename(ref: string): string;

package/lib/FilesGenerator.js

@@ -0,0 +1,38 @@
+export class FilesGenerator {
+    static async merge_files(generators, onto = undefined) {
+        onto = onto || {};
+        for (const generator of generators) {
+            for await (const entry of generator.generate_files()) {
+                if (!(entry.file in onto)) {
+                    onto[entry.file] = [];
+                }
+                onto[entry.file].push(entry.node);
+            }
+        }
+        return onto;
+    }
+}
+export class FromArray extends FilesGenerator {
+    entries;
+    constructor(entries) {
+        super();
+        this.entries = entries;
+    }
+    async *generate_files() {
+        await Promise.resolve(); // lazier than figuring out the correct syntax
+        if (this.entries.length > 0) {
+            yield* this.entries; // phpstorm doesn't track this as a query 🤷‍♂️
+        }
+    }
+}
+export function guess_filename(ref) {
+    if (/^FG[A-Za-z]+([-_]{2,}[A-Za-z-_]+)?$/.test(ref)) {
+        return `classes/CoreUObject/${ref.split(/[-_]{2,}/)[0]}.ts`;
+    }
+    else if (ref.startsWith('NativeClass--')
+        || ref.startsWith('EditorCurveData--')) {
+        return 'classes/base.ts';
+    }
+    return 'common/unassigned.ts';
+}
+//# sourceMappingURL=FilesGenerator.js.map

package/lib/MarkdownUtilities.d.ts

@@ -0,0 +1,16 @@
+export type progress_group = {
+    members: string[];
+    subgroups: {
+        [key: string]: progress_group;
+    };
+};
+export declare function remap(group: progress_group): void;
+export declare function reduce(group: progress_group, title?: string, current_depth?: number): {
+    title: string;
+    members: string[];
+    depth: number;
+}[];
+export declare function remove_indentation(input: string): string;
+export interface GeneratesMarkdown {
+    generate_markdown(): Promise<string>;
+}

package/lib/MarkdownUtilities.js

@@ -0,0 +1,68 @@
+export function remap(group) {
+    const subgroups = Object.keys(group.subgroups);
+    const retain = [];
+    const remap_items = {};
+    for (const item of group.members) {
+        let retain_item = true;
+        for (const subgroup of subgroups) {
+            if (item.startsWith(subgroup)) {
+                if (!(subgroup in remap_items)) {
+                    remap_items[subgroup] = [];
+                }
+                remap_items[subgroup].push(item);
+                retain_item = false;
+                break;
+            }
+        }
+        if (retain_item) {
+            retain.push(item);
+        }
+    }
+    group.members = retain;
+    for (const entry of Object.entries(remap_items)) {
+        const [subgroup, items] = entry;
+        group.subgroups[subgroup].members = [
+            ...items,
+            ...group.subgroups[subgroup].members,
+        ];
+    }
+    for (const subgroup of Object.values(group.subgroups)) {
+        remap(subgroup);
+    }
+}
+export function reduce(group, title = 'Basic Types', current_depth = 1) {
+    const head = [];
+    if (group.members.length > 0) {
+        head.push({
+            title,
+            depth: 1 === current_depth ? 2 : current_depth,
+            members: group.members,
+        });
+    }
+    return [
+        ...head,
+        ...Object.entries(group.subgroups)
+            .map((subgroup) => {
+            return reduce(subgroup[1], subgroup[0], current_depth + 1);
+        })
+            .reduce((was, is) => {
+            was.push(...is);
+            return was;
+        }, [])
+            .sort((a, b) => {
+            return a.title.localeCompare(b.title);
+        }),
+    ];
+}
+export function remove_indentation(input) {
+    const str = input.replace(/^\n+/, '').replace(/\n+\t*$/, '\n');
+    const matches = /^(\t+)/gm.exec(str);
+    if (matches) {
+        const min = matches.reduce((was, is) => Math.min(was, is.length), Infinity);
+        if (min > 0 && min !== Infinity) {
+            return str.replace(new RegExp(`^\t{${min}}`, 'gm'), '');
+        }
+    }
+    return str;
+}
+//# sourceMappingURL=MarkdownUtilities.js.map

package/lib/StringStartsWith.d.ts

@@ -0,0 +1,10 @@
+export type StringStartsWith<Prefix extends string, Suffix extends string = string> = string & keyof {
+    [T in keyof {
+        [key: string]: unknown;
+    } as T extends string ? `${Prefix}${Suffix}` : never]: string;
+};
+export type local_ref<T extends string> = StringStartsWith<'#/$defs/', T>;
+export declare function local_ref<T extends string = string>(ref_like_string: T): local_ref<T>;
+export declare function is_string(maybe: unknown): maybe is string;
+export declare function is_$ref(maybe: unknown): maybe is (typeof maybe extends string ? local_ref<typeof maybe> : never);
+export declare function $ref_in_array(maybe_$ref: unknown, $ref_array: local_ref<string>[]): maybe_$ref is never;

package/lib/StringStartsWith.js

@@ -0,0 +1,20 @@
+import { NoMatchError, } from './Exceptions';
+export function local_ref(ref_like_string) {
+    if (/\s+/.test(ref_like_string)) {
+        throw new Error('No spacing characters allowed!');
+    }
+    if (ref_like_string.startsWith('#/$defs/')) {
+        throw new NoMatchError(ref_like_string, 'Already a local ref!');
+    }
+    return `#/$defs/${ref_like_string}`;
+}
+export function is_string(maybe) {
+    return 'string' === typeof maybe;
+}
+export function is_$ref(maybe) {
+    return is_string(maybe) && maybe.startsWith('#/$defs/');
+}
+export function $ref_in_array(maybe_$ref, $ref_array) {
+    return is_$ref(maybe_$ref) && $ref_array.includes(maybe_$ref);
+}
+//# sourceMappingURL=StringStartsWith.js.map

package/lib/TsFactoryWrapper.d.ts

@@ -0,0 +1,80 @@
+import ts, { ClassDeclaration, Expression, KeywordTypeSyntaxKind, LiteralTypeNode, MethodDeclaration, NodeArray, NullLiteral, ParenthesizedExpression, PrefixUnaryExpression, PropertyDeclaration, PropertySignature, RegularExpressionLiteral, StringLiteral, SyntaxKind, TemplateExpression, TypeLiteralNode, TypeNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement } from 'typescript';
+declare type supported_class_modifiers = ('export' | 'abstract')[];
+declare type supported_modifier = 'abstract' | 'protected' | 'public' | 'static';
+declare type supported_method_modifiers = [
+    supported_modifier,
+    ...supported_modifier[]
+];
+export declare function adjust_class_name(class_name: string): string;
+export declare const modifier_map: {
+    [key: string]: () => ts.ModifierToken<ts.ModifierSyntaxKind>;
+};
+type modifier = Exclude<keyof typeof modifier_map, number>;
+export declare function create_modifiers(first: modifier, ...rest: modifier[]): [ts.ModifierToken<ts.ModifierSyntaxKind>, ...ts.ModifierToken<ts.ModifierSyntaxKind>[]];
+export declare function type_reference_node(name: string, ...type_arguments: TypeNode[]): TypeReferenceNode;
+export type create_class_options = {
+    modifiers?: supported_class_modifiers;
+    extends?: string;
+};
+export declare function createClass(name: string, members: (PropertyDeclaration | MethodDeclaration)[], options?: create_class_options, type_parameters?: [TypeParameterDeclaration, ...TypeParameterDeclaration[]] | undefined): ClassDeclaration;
+export declare function createParameter(name: string | ts.ObjectBindingPattern, type: KeywordTypeSyntaxKind | TypeNode, initializer?: ts.Expression | undefined): ts.ParameterDeclaration;
+declare type createMethod_parameters_entry = [string, KeywordTypeSyntaxKind | ts.TypeNode] | ts.ParameterDeclaration;
+export declare function create_method_with_type_parameters(name: string, type_parameters: [
+    ts.TypeParameterDeclaration,
+    ...ts.TypeParameterDeclaration[]
+], parameters: createMethod_parameters_entry[], body: ts.Statement[], modifiers: supported_method_modifiers, return_type?: ts.TypeNode | undefined): ts.MethodDeclaration;
+export declare function create_method_without_type_parameters(name: string, modifiers: supported_method_modifiers, parameters: createMethod_parameters_entry[], body: ts.Statement[], return_type?: ts.TypeNode | undefined): ts.MethodDeclaration;
+export declare function create_throw(throw_this: string, throw_arguments: [ts.Expression, ...ts.Expression[]], type_parameters?: [ts.TypeNode, ...ts.TypeNode[]] | undefined): ts.ThrowStatement;
+export declare function create_throw_if(throw_this: string, throw_if: ts.Expression, throw_arguments: [ts.Expression, ...ts.Expression[]], type_parameters?: [ts.TypeNode, ...ts.TypeNode[]] | undefined): ts.IfStatement;
+export declare function template_expression_from_string(template: string): TemplateExpression;
+export declare function parenthesize(expression: Expression): ParenthesizedExpression;
+export declare function create_property_access(on: Expression, property: string): ts.PropertyAccessExpression;
+declare const type_map: {
+    boolean: ts.SyntaxKind;
+    number: ts.SyntaxKind;
+    object: ts.SyntaxKind;
+    string: ts.SyntaxKind;
+    undefined: ts.SyntaxKind;
+    never: ts.SyntaxKind;
+    unknown: ts.SyntaxKind;
+};
+export declare function create_type(type: keyof typeof type_map): ts.KeywordTypeNode;
+export declare function create_object_type_from_entries(entries: [string, TypeNode][], required?: [string, ...string[]]): TypeLiteralNode;
+export declare function createPropertySignature(property: string, type: TypeNode, required?: boolean): PropertySignature;
+export declare function needs_element_access(property: string): boolean;
+export declare function computed_property_name_or_undefined(property: string): ts.ComputedPropertyName | undefined;
+export declare function property_name_or_computed<T extends string = string>(property: T): T | ts.ComputedPropertyName;
+export declare function minimum_size_array_of_single_type(repeat: number, generate: () => ts.TypeNode, max?: number | undefined): ts.TupleTypeNode;
+export declare function create_this_assignment(property: string, identifier: string | ts.Expression): ts.ExpressionStatement;
+export declare function create_index_access(identifier: string, index: number): ts.ElementAccessExpression;
+export declare function create_literal<T1 extends string | RegExp | null = string | RegExp | null, T2 = T1 extends null ? ts.LiteralTypeNode & {
+    literal: NullLiteral;
+} : (T1 extends RegExp ? RegularExpressionLiteral : (ts.LiteralTypeNode & {
+    literal: StringLiteral;
+}))>(value: T1): T2;
+export declare function create_union(a: ts.TypeNode, b: ts.TypeNode, ...rest: ts.TypeNode[]): ts.UnionTypeNode;
+declare type lazy_union_item = string | {
+    $ref: string;
+} | ({
+    type: string;
+} & ({
+    pattern: string;
+} | {
+    const: string;
+}));
+export declare function create_lazy_union(a: lazy_union_item, b: lazy_union_item, ...rest: lazy_union_item[]): ts.UnionTypeNode;
+export declare function possibly_create_lazy_union(items: lazy_union_item[]): ts.TypeNode;
+type string_literal = LiteralTypeNode & {
+    literal: StringLiteral;
+};
+export type non_empty_string_literal_union = UnionTypeNode & {
+    types: NodeArray<string_literal> & [string_literal, ...string_literal[]];
+};
+export declare function create_typed_union(items: [string, ...string[]]): non_empty_string_literal_union;
+export declare function create_const_declaration_list(first: VariableDeclaration, ...rest: VariableDeclaration[]): VariableDeclarationList;
+export declare function create_const_statement(first: VariableDeclaration, ...rest: VariableDeclaration[]): VariableStatement;
+export declare function variable(name: string, value: Expression, type?: TypeNode | undefined): VariableDeclaration;
+export declare function not(expression: Expression): PrefixUnaryExpression & {
+    operator: SyntaxKind.ExclamationToken;
+};
+export {};