@satisfactory-dev/docs.json.ts 0.6.1

package/lib/DocsToAutoImport/NodeExtraction.js

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import { EntityName_array_from_Node_array, } from './from_Node_array';
+export class NodeExtraction {
+    results = [];
+    constructor(nodes) {
+        if (nodes.length < 1) {
+            return;
+        }
+        const sub_nodes = [];
+        for (const node of this.extract(nodes)) {
+            if (ts.isEntityName(node)) {
+                this.results.push(node);
+            }
+            else {
+                sub_nodes.push(node);
+            }
+        }
+        this.results.push(...EntityName_array_from_Node_array(sub_nodes));
+    }
+}
+//# sourceMappingURL=NodeExtraction.js.map

package/lib/DocsToAutoImport/PropertyDeclarations.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { Node, PropertyDeclaration } from 'typescript';
+export declare class PropertyDeclarations extends NodeExtraction<PropertyDeclaration> {
+    protected extract(nodes: PropertyDeclaration[]): Node[];
+}

package/lib/DocsToAutoImport/PropertyDeclarations.js

@@ -0,0 +1,10 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class PropertyDeclarations extends NodeExtraction {
+    extract(nodes) {
+        return nodes
+            .map((e) => [e.type, e.initializer])
+            .flat()
+            .filter((maybe) => !!maybe);
+    }
+}
+//# sourceMappingURL=PropertyDeclarations.js.map

package/lib/DocsToAutoImport/TupleTypeNodes.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { Node, TupleTypeNode } from 'typescript';
+export declare class TupleTypeNodes extends NodeExtraction<TupleTypeNode> {
+    extract(nodes: TupleTypeNode[]): Node[];
+}

package/lib/DocsToAutoImport/TupleTypeNodes.js

@@ -0,0 +1,7 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class TupleTypeNodes extends NodeExtraction {
+    extract(nodes) {
+        return nodes.map((e) => e.elements).flat();
+    }
+}
+//# sourceMappingURL=TupleTypeNodes.js.map

package/lib/DocsToAutoImport/TypeLiteralNodes.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { Node, TypeLiteralNode } from 'typescript';
+export declare class TypeLiteralNodes extends NodeExtraction<TypeLiteralNode> {
+    protected extract(nodes: TypeLiteralNode[]): Node[];
+}

package/lib/DocsToAutoImport/TypeLiteralNodes.js

@@ -0,0 +1,33 @@
+import { NodeExtraction, } from './NodeExtraction';
+import ts from 'typescript';
+import { NoMatchError, } from '../Exceptions';
+export class TypeLiteralNodes extends NodeExtraction {
+    extract(nodes) {
+        if (nodes.length < 1) {
+            return [];
+        }
+        const elements = nodes.map((e) => e.members).flat();
+        const other_elements = [];
+        const types = [];
+        for (const element of elements) {
+            if (ts.isPropertySignature(element) && !!element.type) {
+                types.push(element.type);
+            }
+            else if (ts.isIndexSignatureDeclaration(element)) {
+                types.push(...[
+                    element.type,
+                    ...(element.typeParameters || []),
+                    ...element.parameters,
+                ].filter((maybe) => !!maybe));
+            }
+            else {
+                other_elements.push(element);
+            }
+        }
+        if (other_elements.length) {
+            throw new NoMatchError(other_elements, 'Unsupported elements found!');
+        }
+        return types;
+    }
+}
+//# sourceMappingURL=TypeLiteralNodes.js.map

package/lib/DocsToAutoImport/TypeReferenceNodes.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { Node, TypeReferenceNode } from 'typescript';
+export declare class TypeReferenceNodes extends NodeExtraction<TypeReferenceNode> {
+    protected extract(nodes: TypeReferenceNode[]): Node[];
+}

package/lib/DocsToAutoImport/TypeReferenceNodes.js

@@ -0,0 +1,7 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class TypeReferenceNodes extends NodeExtraction {
+    extract(nodes) {
+        return nodes.map((e) => e.typeName);
+    }
+}
+//# sourceMappingURL=TypeReferenceNodes.js.map

package/lib/DocsToAutoImport/from_Node_array.d.ts

@@ -0,0 +1,3 @@
+import { EntityName, Node } from 'typescript';
+export declare function EntityName_array_from_Node_array(nodes: Node[]): EntityName[];
+export declare function from_Node_array(nodes: Node[]): string[];

package/lib/DocsToAutoImport/from_Node_array.js

@@ -0,0 +1,245 @@
+import ts from 'typescript';
+import { TypeReferenceNodes, } from './TypeReferenceNodes';
+import { ClassDeclarations, } from './ClassDeclarations';
+import { TupleTypeNodes, } from './TupleTypeNodes';
+import { TypeLiteralNodes, } from './TypeLiteralNodes';
+import { LiteralTypeNodes, } from './LiteralTypeNodes';
+import { ArrayTypeNodes, } from './ArrayTypeNodes';
+import { MethodDeclarations, } from './MethodDeclarations';
+import { PropertyDeclarations, } from './PropertyDeclarations';
+import { FunctionDeclarations, } from './FunctionDeclaration';
+import { NoMatchError, } from '../Exceptions';
+const recursion_limit = 10;
+export function EntityName_array_from_Node_array(nodes) {
+    if (nodes.length < 1) {
+        return [];
+    }
+    const class_declarations = [];
+    const tuple_types = [];
+    const type_literals = [];
+    const literal_types = [];
+    const reference_nodes = [];
+    const array_types = [];
+    const method_declarations = [];
+    const property_declarations = [];
+    const function_types = [];
+    const sub_nodes = [];
+    const entity_names = [];
+    const others = [];
+    for (const node of nodes) {
+        if (ts.isEntityName(node)) {
+            entity_names.push(node);
+        }
+        else if (ts.isClassDeclaration(node)) {
+            class_declarations.push(node);
+        }
+        else if (ts.isUnionTypeNode(node)
+            || ts.isIntersectionTypeNode(node)) {
+            sub_nodes.push(...node.types);
+        }
+        else if (ts.isTupleTypeNode(node)) {
+            tuple_types.push(node);
+        }
+        else if (ts.isTypeLiteralNode(node)) {
+            type_literals.push(node);
+        }
+        else if (ts.isLiteralTypeNode(node)) {
+            literal_types.push(node);
+        }
+        else if (ts.isTypeReferenceNode(node)) {
+            reference_nodes.push(node);
+            sub_nodes.push(...(node.typeArguments || []));
+        }
+        else if (ts.isArrayTypeNode(node)) {
+            array_types.push(node);
+        }
+        else if (ts.isParenthesizedTypeNode(node)
+            || ts.isTypeOperatorNode(node)
+            || ts.isRestTypeNode(node)
+            || ts.isTypeAliasDeclaration(node)) {
+            sub_nodes.push(node.type);
+            if (ts.isTypeAliasDeclaration(node)) {
+                sub_nodes.push(...(node.typeParameters || []));
+            }
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            method_declarations.push(node);
+        }
+        else if (ts.isPropertyDeclaration(node)) {
+            property_declarations.push(node);
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            function_types.push(node);
+        }
+        else if (ts.isArrowFunction(node)) {
+            sub_nodes.push(...[
+                ...node.parameters,
+                ...(node.typeParameters || []),
+                node.body,
+                ...((node.type && ts.isTypeLiteralNode(node.type))
+                    ? [node.type]
+                    : []),
+            ].filter(e => !!e));
+        }
+        else if (ts.isBlock(node)) {
+            sub_nodes.push(...node.statements);
+        }
+        else if (ts.isTypeParameterDeclaration(node)) {
+            sub_nodes.push(...[node.name, node.constraint, node.expression].filter((maybe) => {
+                return undefined !== maybe;
+            }));
+        }
+        else if (ts.isIfStatement(node)) {
+            sub_nodes.push(...[
+                node.elseStatement,
+                node.expression,
+                node.thenStatement,
+            ].filter((maybe) => !!maybe));
+        }
+        else if (ts.isVariableStatement(node)) {
+            sub_nodes.push(node.declarationList);
+        }
+        else if (ts.isReturnStatement(node)
+            || ts.isExpressionStatement(node)
+            || ts.isThrowStatement(node)
+            || ts.isParenthesizedExpression(node)) {
+            if (node.expression) {
+                sub_nodes.push(node.expression);
+            }
+        }
+        else if (ts.isParameter(node)) {
+            sub_nodes.push(...[node.initializer, node.type].filter((maybe) => !!maybe));
+        }
+        else if (ts.isNewExpression(node)) {
+            sub_nodes.push(...[
+                ...(node.arguments || []),
+                node.expression,
+                ...(node.typeArguments || []),
+            ].filter((maybe) => !!maybe));
+        }
+        else if (ts.isPrefixUnaryExpression(node)) {
+            sub_nodes.push(node.operand);
+        }
+        else if (ts.isBinaryExpression(node)) {
+            sub_nodes.push(...[node.left, node.right].filter((maybe) => !ts.isIdentifier(maybe)));
+        }
+        else if (ts.isVariableDeclarationList(node)) {
+            sub_nodes.push(...node.declarations);
+        }
+        else if (ts.isConditionalTypeNode(node)) {
+            sub_nodes.push(node.trueType, node.checkType, node.extendsType, node.falseType);
+        }
+        else if (ts.isObjectBindingPattern(node)) {
+            sub_nodes.push(...node.elements);
+        }
+        else if (ts.isAsExpression(node)) {
+            sub_nodes.push(node.expression, node.type);
+        }
+        else if (ts.isElementAccessExpression(node)) {
+            sub_nodes.push(node.argumentExpression, node.expression);
+        }
+        else if (ts.isCallExpression(node)) {
+            sub_nodes.push(...[
+                ...node.arguments,
+                node.expression,
+                ...(node.typeArguments || []),
+            ].filter((maybe) => !!maybe));
+        }
+        else if (ts.isVariableDeclaration(node)) {
+            sub_nodes.push(...[
+                node.initializer,
+                node.type,
+                node.initializer,
+            ].filter((maybe) => !!maybe));
+        }
+        else if (ts.isTypeQueryNode(node)) {
+            sub_nodes.push(...[...(node.typeArguments || []), node.exprName].filter((maybe) => !!maybe));
+        }
+        else if (ts.isBindingElement(node)) {
+            sub_nodes.push(...[node.initializer].filter((maybe) => !!maybe));
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            sub_nodes.push(node.expression);
+        }
+        else if (ts.isTemplateExpression(node)
+            || ts.isTemplateLiteralTypeNode(node)) {
+            sub_nodes.push(node.head, ...node.templateSpans);
+        }
+        else if (ts.isTemplateSpan(node)) {
+            sub_nodes.push(node.expression, node.literal);
+        }
+        else if (ts.isMappedTypeNode(node)) {
+            sub_nodes.push(...[
+                node.nameType,
+                ...(node.members || []),
+                node.type,
+                node.typeParameter,
+            ].filter((maybe) => !!maybe));
+        }
+        else if (ts.isTemplateLiteralTypeSpan(node)) {
+            sub_nodes.push(node.literal, node.type);
+        }
+        else if (ts.isHeritageClause(node)) {
+            sub_nodes.push(...node.types);
+        }
+        else if (ts.isExpressionWithTypeArguments(node)) {
+            sub_nodes.push(node.expression, ...(node.typeArguments || []));
+        }
+        else if (ts.isExportDeclaration(node)
+            && node.exportClause
+            && ts.isNamedExports(node.exportClause)) {
+            sub_nodes.push(...node.exportClause.elements.map((sub_node) => {
+                return sub_node.name;
+            }));
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            sub_nodes.push(...node.properties);
+        }
+        else if (ts.isPropertyAssignment(node)) {
+            sub_nodes.push(node.initializer);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            sub_nodes.push(...node.elements);
+        }
+        else if (ts.isComputedPropertyName(node)) {
+            sub_nodes.push(node.expression);
+        }
+        else if (!ts.isToken(node)
+            && !ts.isNamedExports(node)
+            && !ts.isShorthandPropertyAssignment(node)) {
+            others.push(node);
+        }
+    }
+    if (others.length) {
+        throw new NoMatchError(others, 'Unsupported types found!');
+    }
+    return [
+        ...new ClassDeclarations(class_declarations).results,
+        ...new TupleTypeNodes(tuple_types).results,
+        ...new TypeLiteralNodes(type_literals).results,
+        ...new LiteralTypeNodes(literal_types).results,
+        ...new TypeReferenceNodes(reference_nodes).results,
+        ...new ArrayTypeNodes(array_types).results,
+        ...new MethodDeclarations(method_declarations).results,
+        ...new PropertyDeclarations(property_declarations).results,
+        ...new FunctionDeclarations(function_types).results,
+        ...EntityName_array_from_Node_array(sub_nodes),
+        ...entity_names,
+    ];
+}
+export function from_Node_array(nodes) {
+    return [
+        ...EntityName_array_from_Node_array(nodes).map((checking) => {
+            let recursion_iteration = 0;
+            while (ts.isQualifiedName(checking)) {
+                if (recursion_iteration > recursion_limit) {
+                    throw new Error('Recursion limit exceeded!');
+                }
+                checking = checking.left;
+                ++recursion_iteration;
+            }
+            return checking.escapedText.toString();
+        }),
+    ];
+}
+//# sourceMappingURL=from_Node_array.js.map

package/lib/DocsTsAutoImports.d.ts

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import { ImportTracker } from './TypesGeneration';
+export declare class DocsTsAutoImports {
+    private readonly comes_from;
+    private readonly files_entries;
+    constructor(files: {
+        [key: string]: ts.Node[];
+    });
+    get imports_come_from(): string;
+    generate(): ImportTracker;
+    protected file_exports(): {
+        [key: string]: [string, ...string[]];
+    };
+    private static filter_node;
+    private static filter_nodes;
+    private static has_export;
+    private static is_Identifier;
+    private static is_named_ClassDeclaration;
+    private static is_named_FunctionDeclaration;
+    private static node_IdentifierName;
+}

package/lib/DocsTsAutoImports.js

@@ -0,0 +1,110 @@
+import ts from 'typescript';
+import { ImportTracker, } from './TypesGeneration';
+import { basename, dirname, relative, } from 'node:path';
+import { from_Node_array, } from './DocsToAutoImport/from_Node_array';
+import { NoMatchError, } from './Exceptions';
+export class DocsTsAutoImports {
+    comes_from = {};
+    files_entries;
+    constructor(files) {
+        this.files_entries = Object.entries(files);
+    }
+    get imports_come_from() {
+        return `${JSON.stringify(this.comes_from, null, '\t')}\n`;
+    }
+    generate() {
+        const file_exports = this.file_exports();
+        for (const entry of Object.entries(file_exports)) {
+            const [filename, exports_these] = entry;
+            for (const export_name of exports_these) {
+                if (export_name in this.comes_from) {
+                    throw new NoMatchError(entry, `${export_name} conflict!`);
+                }
+                this.comes_from[export_name] = filename.replace(/\.ts$/, '');
+            }
+        }
+        const auto_imports = {};
+        for (const entry of this.files_entries) {
+            const [filename, nodes] = entry;
+            const node_names = from_Node_array(nodes);
+            const reference_names = [...node_names]
+                .filter((maybe) => maybe in this.comes_from)
+                .filter((maybe) => filename.replace(/\.ts$/, '') !==
+                this.comes_from[maybe]);
+            if (reference_names.length) {
+                if (!(filename in auto_imports)) {
+                    auto_imports[filename] = {};
+                }
+                for (const import_this of reference_names) {
+                    let import_from = `${relative(dirname(filename), dirname(this.comes_from[import_this]))}/${basename(this.comes_from[import_this])}`;
+                    if (import_from.startsWith('/')) {
+                        import_from = `.${import_from}`;
+                    }
+                    if (!import_from.startsWith('.')) {
+                        import_from = `./${import_from}`;
+                    }
+                    if (!(import_from in auto_imports[filename])) {
+                        auto_imports[filename][import_from] = [];
+                    }
+                    if (!auto_imports[filename][import_from].includes(import_this)) {
+                        auto_imports[filename][import_from].push(import_this);
+                    }
+                }
+            }
+        }
+        const import_tracker = new ImportTracker();
+        import_tracker.merge_and_set_imports(auto_imports);
+        return import_tracker;
+    }
+    file_exports() {
+        const file_exports = {};
+        for (const entry of this.files_entries) {
+            const [filename, nodes] = entry;
+            const check_these = DocsTsAutoImports.filter_nodes(nodes);
+            for (const checking of check_these) {
+                if (!(filename in file_exports)) {
+                    file_exports[filename] = [
+                        DocsTsAutoImports.node_IdentifierName(checking),
+                    ];
+                }
+                else {
+                    file_exports[filename].push(DocsTsAutoImports.node_IdentifierName(checking));
+                }
+            }
+        }
+        return file_exports;
+    }
+    static filter_node(maybe) {
+        return ((this.is_named_ClassDeclaration(maybe)
+            || this.is_named_FunctionDeclaration(maybe)
+            || ts.isTypeAliasDeclaration(maybe))
+            && this.has_export(maybe));
+    }
+    static filter_nodes(nodes) {
+        return nodes.filter((maybe) => {
+            return this.filter_node(maybe);
+        });
+    }
+    static has_export(node) {
+        return (!!node.modifiers
+            && node.modifiers
+                .map((inner_maybe) => inner_maybe.kind)
+                .includes(ts.SyntaxKind.ExportKeyword));
+    }
+    static is_Identifier(maybe) {
+        return !!maybe && ts.isIdentifier(maybe);
+    }
+    static is_named_ClassDeclaration(node) {
+        return (ts.isClassDeclaration(node)
+            && DocsTsAutoImports.is_Identifier(node.name));
+    }
+    static is_named_FunctionDeclaration(node) {
+        return (ts.isFunctionDeclaration(node)
+            && DocsTsAutoImports.is_Identifier(node.name));
+    }
+    static node_IdentifierName(node) {
+        const from = ts.isTypeReferenceNode(node) ? node.typeName : node.name;
+        return from.escapedText.toString();
+    }
+}
+//# sourceMappingURL=DocsTsAutoImports.js.map

package/lib/DocsTsGenerator/FilesGenerator.d.ts

@@ -0,0 +1,25 @@
+import { FilesGenerator as Base } from '../FilesGenerator';
+import { ValidateFunction } from 'ajv/dist/2020';
+import { TypeAliasDeclaration, TypeNode } from 'typescript';
+import { TypeDefinitionDiscovery } from '../TypeDefinitionDiscovery';
+import { DocsDataItem } from '../DocsTsGenerator';
+export declare class FilesGenerator extends Base {
+    private readonly discovery;
+    private readonly is_NativeClass;
+    private readonly types;
+    private readonly validations;
+    constructor(validations: ValidateFunction[], discovery: TypeDefinitionDiscovery);
+    generate_files(): AsyncGenerator<{
+        file: string;
+        node: TypeAliasDeclaration;
+    }, void, unknown>;
+    protected generate_file(entry: DocsDataItem): Promise<{
+        file: string;
+        node: TypeAliasDeclaration;
+    }>;
+    protected generate_files_class_name(value: string): string;
+    protected generate_files_entry_yield(entry_type: TypeNode, entry_class_name: string): {
+        file: string;
+        node: TypeAliasDeclaration;
+    };
+}

package/lib/DocsTsGenerator/FilesGenerator.js

@@ -0,0 +1,52 @@
+import { FilesGenerator as Base, } from '../FilesGenerator';
+import { NoMatchError, } from '../Exceptions';
+import { adjust_unrealengine_value, } from '../CustomParsingTypes/UnrealEngineString';
+import { UnrealEngineString, } from '../TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString';
+import ts from 'typescript';
+import { create_modifiers, } from '../TsFactoryWrapper';
+import { TypesDiscovery, } from '../TypesDiscovery';
+export class FilesGenerator extends Base {
+    discovery;
+    is_NativeClass;
+    types;
+    validations;
+    constructor(validations, discovery) {
+        super();
+        this.validations = validations;
+        this.discovery = discovery;
+        this.is_NativeClass = TypesDiscovery.generate_is_NativeClass(this.discovery.docs);
+        this.types = this.discovery.discover_type_$defs();
+    }
+    async *generate_files() {
+        for (const entry of await this.discovery.docs.get()) {
+            yield await this.generate_file(entry);
+        }
+    }
+    async generate_file(entry) {
+        const types = await this.types;
+        const is_NativeClass = await this.is_NativeClass;
+        const check = this.validations.find(maybe => maybe(entry));
+        if (!check) {
+            throw new NoMatchError({
+                types,
+                entry,
+            }, 'Could not find matching validator!');
+        }
+        else if (!is_NativeClass(entry)) {
+            throw new NoMatchError(entry, 'Entry not a general NativeClass!');
+        }
+        const entry_type = this.discovery.find(types.found_classes[this.validations.indexOf(check)]);
+        return this.generate_files_entry_yield(entry_type, this.generate_files_class_name(entry.NativeClass));
+    }
+    generate_files_class_name(value) {
+        return adjust_unrealengine_value(UnrealEngineString.fromString(value).right);
+    }
+    generate_files_entry_yield(entry_type, entry_class_name) {
+        const entry_filename = `classes/CoreUObject/${entry_class_name}.ts`;
+        return {
+            file: entry_filename,
+            node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), `${entry_class_name}__NativeClass`, undefined, entry_type),
+        };
+    }
+}
+//# sourceMappingURL=FilesGenerator.js.map

package/lib/DocsTsGenerator.d.ts

@@ -0,0 +1,47 @@
+import Ajv, { ErrorObject, SchemaObject } from 'ajv/dist/2020';
+import update8_schema from '../schema/update8.schema.json';
+import { BuiltInParserName } from 'prettier';
+export declare class ValidationError extends Error {
+    readonly errors: ErrorObject[];
+    readonly json: unknown;
+    constructor(message: string, errors: ErrorObject[] | undefined | null, json: unknown);
+}
+export type DocsDataItem_Classes_entry<TypeOfUnknownProperties = unknown> = ({
+    [key: string]: TypeOfUnknownProperties;
+} & {
+    ClassName: string;
+});
+export type DocsDataItem<TypeOfUnknownProperties = unknown, TypeOfNativeClass = string> = {
+    NativeClass: TypeOfNativeClass;
+    Classes: DocsDataItem_Classes_entry<TypeOfUnknownProperties>[];
+};
+export type DocsData = [DocsDataItem, ...DocsDataItem[]];
+export declare class DocsTsGenerator {
+    private docs;
+    private readonly cache_path;
+    private readonly docs_path;
+    readonly ajv: Ajv;
+    static readonly PERF_EARLY_RETURN = "Early Return of Docs.json";
+    static readonly PERF_FAILURE = "Failure to load Docs.json";
+    static readonly PERF_FILE_PARSED = "Docs.json contents parsed";
+    static readonly PERF_FILE_READ = "Docs.json contents read";
+    static readonly PERF_START_LOADING_JSON = "Start Loading Docs.json";
+    static readonly PERF_VALIDATION_COMPILED = "Docs.json validation compiled";
+    static readonly PERF_VALIDATION_FINISHED = "Docs.json validation finished";
+    static readonly PERF_VALIDATION_PRECOMPILE = "Docs.json validation pre-compilation started";
+    static readonly PERF_VALIDATION_STARTED = "Docs.json validation started";
+    constructor({ ajv, docs_path, cache_path, }: {
+        ajv: Ajv;
+        docs_path: string | DocsData;
+        cache_path?: string;
+    });
+    definition($ref: string): Promise<SchemaObject>;
+    get(): Promise<DocsData>;
+    schema(): Promise<typeof update8_schema>;
+    private load;
+    private load_from_file;
+    private validate;
+    private validate_schema;
+}
+export declare function format_code(code: string, parser?: BuiltInParserName): Promise<string>;
+export declare function eslint_generated_types(parent_folder: string): Promise<void>;