@satisfactory-dev/docs.json.ts 0.6.1

package/lib/TypeDefinitionDiscovery.js

@@ -0,0 +1,376 @@
+import { TypesDiscovery, } from './TypesDiscovery';
+import { is_non_empty_array, object_has_non_empty_array_property, object_has_property, value_is_non_array_object, } from './CustomParsingTypes/CustomPairingTypes';
+import { is_string, } from './StringStartsWith';
+import ts from 'typescript';
+import { Const, } from './TypeDefinitionDiscovery/JsonSchema/String/Const';
+import { Pattern, } from './TypeDefinitionDiscovery/JsonSchema/String/Pattern';
+import { Enum, } from './TypeDefinitionDiscovery/JsonSchema/String/Enum';
+import { BooleanEnum, } from './TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum';
+import { string_starts_with, } from './TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
+import { UnrealEngineString, } from './TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString';
+import { NonEmptyString, NonEmptyStringWithExclusions, StringType, } from './TypeDefinitionDiscovery/JsonSchema/String';
+import { FilesGenerator, guess_filename, } from './FilesGenerator';
+import { adjust_class_name, create_modifiers, } from './TsFactoryWrapper';
+import { reduce, remap, remove_indentation, } from './MarkdownUtilities';
+import { compile, } from './AjvUtilities';
+import { NoMatchError, } from './Exceptions';
+function is_schema_with_$defs(schema, discovered_types) {
+    return (object_has_property(schema, '$defs', value_is_non_array_object)
+        && Object.keys(schema.$defs).every(maybe => (maybe.startsWith('#/$defs/')
+            ? maybe
+            : `#/$defs/${maybe}`) in discovered_types)
+        && Object.keys(discovered_types).every(maybe => {
+            const ref = (maybe.startsWith('#/$defs/')
+                ? maybe.substring(8)
+                : maybe);
+            return value_is_non_array_object(schema.$defs[ref]);
+        }));
+}
+export class TypeDefinitionDiscovery extends FilesGenerator {
+    $ref_discovery;
+    candidates;
+    docs;
+    types_discovery;
+    constructor(types_discovery, type_definition_discover, docs) {
+        super();
+        this.types_discovery = new TypesDiscovery(types_discovery, docs);
+        this.candidates = type_definition_discover;
+        this.docs = docs;
+    }
+    add_candidates(...candidates) {
+        this.candidates.push(...candidates);
+    }
+    async discover_type_$defs() {
+        if (!this.$ref_discovery) {
+            const discovered_types = await this.types_discovery.discover_types();
+            if (discovered_types.missed_types.length > 0) {
+                throw new Error(`Missing some type $defs:\n${discovered_types.missed_types.join('\n')}`);
+            }
+            else if (!is_non_empty_array(discovered_types.discovered_types, is_string)) {
+                throw new Error('No types discovered!');
+            }
+            const discovered_types_as_object = Object.fromEntries(discovered_types.discovered_types.map(e => [e, true]));
+            const schema = await this.schema_from_json(discovered_types_as_object);
+            this.$ref_discovery = Promise.resolve(this.discover_type_definitions_from(schema, discovered_types_as_object));
+        }
+        return this.$ref_discovery;
+    }
+    find(maybe) {
+        const type = this.search(maybe);
+        if (!type) {
+            throw new NoMatchError(maybe, 'Could not find a match!');
+        }
+        return type;
+    }
+    async *generate_files() {
+        const types = await this.discover_type_$defs();
+        for (const entry of Object.entries(types.found_types)) {
+            const [definition, generator] = entry;
+            const $ref = definition.substring(8);
+            const target_file = guess_filename($ref);
+            yield {
+                file: target_file,
+                node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), adjust_class_name(`${$ref}__type`), undefined, generator(await this.docs.definition($ref))),
+            };
+        }
+    }
+    async generate_markdown() {
+        const grouped_progress = {
+            members: [],
+            subgroups: {},
+        };
+        const manual_groups = {
+            class: '',
+            'class--no-description': '',
+            'class--no-description-or-display-name': '',
+            'color-decimal--semi-native': 'color',
+            'decimal-string': '',
+            'decimal-string--signed': '',
+            'integer-string': '',
+            'integer-string--signed': '',
+            'FGAmmoTypeInstantHit--base': 'FGAmmoType',
+            'FGAmmoTypeInstantHit--chaos': 'FGAmmoType',
+            'FGAmmoTypeInstantHit--standard': 'FGAmmoType',
+            FGAmmoTypeProjectile: 'FGAmmoType',
+            'FGAmmoTypeProjectile--base': 'FGAmmoType',
+            xyz: 'vectors',
+            'xyz--semi-native': 'vectors',
+            xy: 'vectors',
+            'xy--integer': 'vectors',
+            'xy--semi-native': 'vectors',
+            'xyz--integer': 'vectors',
+            quaternion: 'vectors',
+            'quaternion--semi-native': 'vectors',
+            'pitch-yaw-roll': 'vectors',
+            'FGEquipmentDescriptor--base': 'FGEquipment',
+        };
+        const discovered_types = await this.types_discovery.discover_types();
+        const all_referenced_types = [
+            ...discovered_types.discovered_types,
+            ...discovered_types.missed_types,
+        ].map(e => e.substring(8)).sort((a, b) => a.localeCompare(b));
+        const supported_types = discovered_types.discovered_types.map(e => e.substring(8));
+        for (const item of all_referenced_types) {
+            const parts = item.split('--');
+            let checking = grouped_progress;
+            if (item in manual_groups) {
+                if ('' !== manual_groups[item]) {
+                    if (!(manual_groups[item] in checking.subgroups)) {
+                        checking.subgroups[manual_groups[item]] = {
+                            members: [],
+                            subgroups: {},
+                        };
+                    }
+                    checking = checking.subgroups[manual_groups[item]];
+                }
+            }
+            else if (parts.length > 1) {
+                for (let iteration = 1; iteration < Math.min(2, parts.length); ++iteration) {
+                    if (!(parts[iteration - 1] in checking.subgroups)) {
+                        checking.subgroups[parts[iteration - 1]] = {
+                            members: [],
+                            subgroups: {},
+                        };
+                    }
+                    checking = checking.subgroups[parts[iteration - 1]];
+                }
+            }
+            if (!checking.members.includes(item)) {
+                checking.members.push(item);
+            }
+        }
+        remap(grouped_progress);
+        return remove_indentation(`
+			# Types Progress
+
+			${((supported_types.length /
+            all_referenced_types.length) *
+            100).toFixed(2)}% Complete (${supported_types.length} of ${all_referenced_types.length})
+
+			${reduce(grouped_progress).map((group) => {
+            return remove_indentation(`
+					${'#'.repeat(group.depth)} ${group.title}
+
+					${group.members.map((key) => {
+                return `-   [${supported_types.includes(key) ? 'x' : ' '}] ${key.replace(/__/g, '\\_\\_')}`;
+            }).join('\n')}`);
+        }).join('\n\n')}
+		`);
+    }
+    discover_type_definitions_from(schema, discovered_types) {
+        const result = {
+            found_types: {},
+            missing_types: [],
+            found_classes: [],
+            missing_classes: [],
+        };
+        const $defs = Object.keys(discovered_types);
+        for (const definition of $defs) {
+            const $ref = definition.substring(8);
+            const generator = this.candidates.find(e => e.check(schema.$defs[$ref]));
+            if (generator) {
+                result.found_types[definition] = generator.generate();
+            }
+            else {
+                result.missing_types.push(definition);
+            }
+        }
+        if (object_has_non_empty_array_property(schema, 'prefixItems', value_is_non_array_object)) {
+            const native_class = compile(this.docs.ajv, {
+                type: 'object',
+                required: ['type', '$ref', 'properties'],
+                additionalProperties: false,
+                $defs: {
+                    $ref_base: {
+                        type: 'object',
+                        required: [
+                            'type',
+                            '$ref',
+                            'unevaluatedProperties',
+                        ],
+                        properties: {
+                            type: {
+                                type: 'string',
+                                const: 'object',
+                            },
+                            $ref: {
+                                type: 'string',
+                                enum: $defs,
+                            },
+                            unevaluatedProperties: {
+                                type: 'boolean',
+                                const: false,
+                            },
+                        },
+                    },
+                    $ref: {
+                        type: 'object',
+                        $ref: '#/$defs/$ref_base',
+                        unevaluatedProperties: false,
+                    },
+                },
+                properties: {
+                    type: { type: 'string', const: 'object' },
+                    $ref: { type: 'string', const: '#/$defs/NativeClass' },
+                    unevaluatedProperties: { type: 'boolean', const: false },
+                    properties: {
+                        type: 'object',
+                        required: ['Classes'],
+                        additionalProperties: false,
+                        properties: { Classes: { oneOf: [
+                                    {
+                                        type: 'object',
+                                        required: [
+                                            'type',
+                                            'minItems',
+                                            'items',
+                                        ],
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                const: 'array',
+                                            },
+                                            minItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            maxItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            items: {
+                                                $ref: '#/$defs/$ref',
+                                            },
+                                        },
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: [
+                                            'type',
+                                            'items',
+                                            'minItems',
+                                        ],
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                const: 'array',
+                                            },
+                                            minItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            maxItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            items: {
+                                                type: 'object',
+                                                required: ['oneOf'],
+                                                additionalProperties: false,
+                                                properties: { oneOf: {
+                                                        type: 'array',
+                                                        minItems: 1,
+                                                        items: {
+                                                            $ref: '#/$defs/$ref',
+                                                        },
+                                                    } },
+                                            },
+                                        },
+                                    },
+                                    {
+                                        type: 'object',
+                                        required: [
+                                            'type',
+                                            'items',
+                                            'minItems',
+                                        ],
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                const: 'array',
+                                            },
+                                            minItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            items: {
+                                                type: 'object',
+                                                $ref: '#/$defs/$ref_base',
+                                                required: [
+                                                    'type',
+                                                    '$ref',
+                                                    'unevaluatedProperties',
+                                                    'properties',
+                                                ],
+                                                unevaluatedProperties: false,
+                                                properties: {
+                                                    properties: {
+                                                        type: 'object',
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                ] } },
+                    },
+                },
+            });
+            for (const item of schema.prefixItems) {
+                if (native_class(item)) {
+                    result.found_classes.push(item);
+                }
+                else {
+                    result.missing_classes.push(item);
+                }
+            }
+            if (result.found_classes.length < 1) {
+                throw new Error('No found classes!');
+            }
+        }
+        result.found_types = Object.fromEntries(Object.entries(result.found_types).sort((a, b) => {
+            return a[0].localeCompare(b[0]);
+        }));
+        return result;
+    }
+    /**
+     * @todo move to DocsTsGenerator
+     */
+    async schema_from_json(discovered_types) {
+        const schema = await this.docs.schema();
+        if (!is_schema_with_$defs(schema, discovered_types)) {
+            throw new Error('Schema $defs not as expected!');
+        }
+        return schema;
+    }
+    search(maybe) {
+        performance.mark(`${this.constructor.name}.search() start`);
+        const generator = this.candidates.find(e => e.check(maybe));
+        if (generator) {
+            const result = generator.generate()(maybe);
+            performance.measure(`${this.constructor.name}.search()`, `${this.constructor.name}.search() start`);
+            return result;
+        }
+        return undefined;
+    }
+    static custom_parsing_discovery(ajv) {
+        return [
+            new string_starts_with(ajv),
+            new UnrealEngineString(ajv),
+        ];
+    }
+    static standard_jsonschema_discovery(ajv) {
+        return [
+            new Const(ajv),
+            new Pattern(ajv),
+            new BooleanEnum(ajv),
+            new Enum(ajv),
+            new StringType(ajv),
+            new NonEmptyString(ajv),
+            new NonEmptyStringWithExclusions(ajv),
+        ];
+    }
+}
+//# sourceMappingURL=TypeDefinitionDiscovery.js.map

package/lib/TypeDefinitionWriter.d.ts

@@ -0,0 +1,22 @@
+import { TypeDefinitionDiscovery } from './TypeDefinitionDiscovery';
+import ts, { ClassDeclaration } from 'typescript';
+import { DocsTsGenerator } from './DocsTsGenerator';
+type class_can_have_tree = ClassDeclaration & {
+    heritageClauses: [{
+        types: [{
+            expression: ts.Identifier;
+        }];
+    }];
+};
+export declare class TypeDefinitionWriter {
+    private _discovery;
+    private prepared;
+    private readonly data_discovery;
+    private readonly docs;
+    constructor(docs: DocsTsGenerator);
+    get discovery(): Promise<TypeDefinitionDiscovery>;
+    write(parent_folder: string, cleanup?: boolean): Promise<void>;
+    private prepare;
+    static can_class_have_tree(class_node: ts.ClassDeclaration): class_node is class_can_have_tree;
+}
+export {};

package/lib/TypeDefinitionWriter.js

@@ -0,0 +1,233 @@
+import { TypesDiscovery, } from './TypesDiscovery';
+import { TypeDefinitionDiscovery, } from './TypeDefinitionDiscovery';
+import { mkdir, unlink, writeFile, } from 'node:fs/promises';
+import { ObjectType, } from './TypeDefinitionDiscovery/JsonSchema/ObjectType';
+import { ArrayType, } from './TypeDefinitionDiscovery/JsonSchema/ArrayType';
+import { ExtendsObject, } from './TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject';
+import { typed_string, } from './TypeDefinitionDiscovery/CustomParsingTypes/typed_string';
+import { oneOf_or_anyOf, } from './TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf';
+import { glob, } from 'glob';
+import { object_has_property, value_is_non_array_object, } from './CustomParsingTypes/CustomPairingTypes';
+import ts from 'typescript';
+import { DocsTsAutoImports, } from './DocsTsAutoImports';
+import { dirname, } from 'node:path';
+import { eslint_generated_types, format_code, } from './DocsTsGenerator';
+import { UnrealEngineString as legacy_UnrealEngineString_module, } from './CustomParsingTypes/UnrealEngineString';
+import { string_starts_with, StringPassedRegExp, } from './TypesGeneration/validators';
+import { NoMatchError, } from './Exceptions';
+import { FilesGenerator, FromArray, } from './FilesGenerator';
+import { FilesGenerator as DocsFiles, } from './DocsTsGenerator/FilesGenerator';
+import { require_non_empty_array, } from './ArrayUtilities';
+import { DataDiscovery, } from './DataDiscovery';
+import { __dirname_from_meta, } from './__dirname';
+import { compile, } from './AjvUtilities';
+const __dirname = __dirname_from_meta(import.meta);
+export class TypeDefinitionWriter {
+    _discovery = undefined;
+    prepared = false;
+    data_discovery;
+    docs;
+    constructor(docs) {
+        this.docs = docs;
+        this.data_discovery = new DataDiscovery(docs);
+    }
+    get discovery() {
+        if (!this._discovery) {
+            const schema = this.docs.schema();
+            const type_definition_discover = require_non_empty_array([
+                ...TypeDefinitionDiscovery.standard_jsonschema_discovery(this.docs.ajv),
+                ...TypeDefinitionDiscovery.custom_parsing_discovery(this.docs.ajv),
+            ]);
+            this._discovery = Promise.resolve(schema.then((schema) => {
+                return new TypeDefinitionDiscovery([
+                    ...TypesDiscovery.standard_jsonschema_discovery(schema),
+                    ...TypesDiscovery.custom_parsing_types(schema),
+                ], type_definition_discover, this.docs);
+            }));
+        }
+        return this._discovery;
+    }
+    async write(parent_folder, cleanup = true) {
+        performance.mark(`${this.constructor.name}.write() start`);
+        await this.prepare();
+        performance.measure(`${this.constructor.name}.write() prepare`, `${this.constructor.name}.write() start`);
+        performance.mark(`${this.constructor.name}.write() start`);
+        const discovery = await this.discovery;
+        performance.measure(`${this.constructor.name}.write() discovery`, `${this.constructor.name}.write() start`);
+        performance.mark(`${this.constructor.name}.write() start`);
+        await writeFile(`${__dirname}/../types-progress.md`, await discovery.generate_markdown());
+        await writeFile(`${__dirname}/../data-progress.md`, await this.data_discovery.generate_markdown());
+        performance.measure(`${this.constructor.name}.write() generate_markdown`, `${this.constructor.name}.write() start`);
+        if (cleanup) {
+            performance.mark(`${this.constructor.name}.write() start`);
+            for (const remove of await glob(`${parent_folder}/**/*.{ts,js,map}`)) {
+                await unlink(remove);
+            }
+            performance.measure(`${this.constructor.name}.write() cleanup`, `${this.constructor.name}.write() start`);
+        }
+        performance.mark(`${this.constructor.name}.write() start`);
+        const types = await discovery.discover_type_$defs();
+        const schema = await this.docs.schema();
+        if (types.missing_classes.length > 0
+            || types.missing_types.length > 0) {
+            throw new NoMatchError({
+                found_types: Object.keys(types.found_types),
+                missing_types: types.missing_types,
+                found_classes: types.found_classes,
+                missing_classes: types.missing_classes,
+            }, 'Some missing types found!');
+        }
+        if (!object_has_property(schema, '$defs', value_is_non_array_object)) {
+            throw new Error('Schema appears to have no $defs');
+        }
+        const validations = types.found_classes.map(e => compile(this.docs.ajv, {
+            $defs: schema.$defs,
+            ...e,
+        }));
+        if (!object_has_property(schema.$defs, 'NativeClass', value_is_non_array_object)) {
+            throw new Error('Could not find NativeClass on provided schema!');
+        }
+        const files = await FilesGenerator.merge_files([
+            discovery,
+            new DocsFiles(validations, discovery),
+            new FromArray([
+                ...legacy_UnrealEngineString_module.CustomGenerators(),
+                string_starts_with,
+                StringPassedRegExp,
+            ]),
+            this.data_discovery,
+        ]);
+        performance.measure(`${this.constructor.name}.write() FilesGenerator`, `${this.constructor.name}.write() start`);
+        performance.mark(`${this.constructor.name}.write() start`);
+        const auto_imports = new DocsTsAutoImports(files);
+        const import_tracker = auto_imports.generate();
+        performance.measure(`${this.constructor.name}.write() auto_imports`, `${this.constructor.name}.write() start`);
+        await writeFile(`${__dirname}/../imports-come-from.json`, auto_imports.imports_come_from);
+        const printer = ts.createPrinter({
+            newLine: ts.NewLineKind.LineFeed,
+        });
+        performance.mark(`${this.constructor.name}.write() start`);
+        for (const entry of Object.entries(files)) {
+            const result_file = ts.createSourceFile(entry[0], '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+            const classes = entry[1].filter(ts.isClassDeclaration);
+            const classes_mapped = Object.fromEntries(classes.map((e) => [e.name?.escapedText + '', e]));
+            const class_can_have_trees = Object.fromEntries(classes
+                .filter(maybe => TypeDefinitionWriter.can_class_have_tree(maybe))
+                .map((e) => [e.name?.escapedText + '', e]));
+            const class_parents = Object.values(class_can_have_trees).map((class_node) => {
+                let checking = class_node;
+                const tree = [class_node.name?.escapedText + ''];
+                while (checking
+                    && TypeDefinitionWriter.can_class_have_tree(checking)
+                    && (checking
+                        .heritageClauses[0]
+                        .types[0]
+                        ?.expression
+                        .escapedText
+                        .toString()) in
+                        class_can_have_trees) {
+                    const parent_class_name = checking
+                        .heritageClauses[0]
+                        .types[0]
+                        .expression
+                        .escapedText
+                        .toString();
+                    if (parent_class_name in classes_mapped) {
+                        tree.push(parent_class_name);
+                        checking = classes_mapped[parent_class_name];
+                    }
+                    else {
+                        checking = undefined;
+                    }
+                }
+                return tree;
+            });
+            const class_parent_classes = class_parents
+                .flat()
+                .reduce((was, is) => {
+                if (!was.includes(is)) {
+                    was.push(is);
+                }
+                return was;
+            }, []);
+            const class_parent_class_max_depth = Object.fromEntries(class_parent_classes
+                .map((thing) => {
+                const includes = class_parents.filter((e) => e.includes(thing));
+                return [thing, includes];
+            })
+                .filter((entry) => {
+                return entry[1].length > 0;
+            })
+                .map((entry) => {
+                return [
+                    entry[0],
+                    Math.max(0, ...entry[1].map((e) => e.indexOf(entry[0]))),
+                ];
+            }));
+            const classes_in_order = class_parent_classes.sort((a, b) => {
+                return (class_parent_class_max_depth[b] -
+                    class_parent_class_max_depth[a]);
+            });
+            const nodes = [
+                ...import_tracker.generate_imports(entry[0]),
+                ...entry[1].sort((a, b) => {
+                    if (ts.isTypeAliasDeclaration(a)
+                        && !ts.isTypeAliasDeclaration(b)) {
+                        return -1;
+                    }
+                    if (ts.isClassDeclaration(a) && ts.isClassDeclaration(b)) {
+                        return (classes_in_order.indexOf(a.name?.escapedText + '') -
+                            classes_in_order.indexOf(b.name?.escapedText + ''));
+                    }
+                    return 0;
+                }),
+            ];
+            const file_name = `${parent_folder}/${entry[0]}`;
+            const dir = dirname(file_name);
+            await mkdir(dir, {
+                recursive: true,
+            });
+            const node_strings = [];
+            for (const node of nodes) {
+                try {
+                    node_strings.push(printer.printNode(ts.EmitHint.Unspecified, node, result_file));
+                }
+                catch (err) {
+                    throw new NoMatchError({
+                        file_name,
+                        node,
+                        err: (err instanceof Error) ? {
+                            message: err.message,
+                            stack: err.stack,
+                        } : err,
+                    }, 'Error printing node!');
+                }
+            }
+            await writeFile(file_name, await format_code(node_strings
+                .join('\n\n')));
+        }
+        performance.measure(`${this.constructor.name}.write() actually write files`, `${this.constructor.name}.write() start`);
+        performance.mark(`${this.constructor.name}.write() start`);
+        await writeFile(`${__dirname}/../data-progress.md`, await this.data_discovery.generate_markdown());
+        performance.measure(`${this.constructor.name}.write() generate_markdown`, `${this.constructor.name}.write() start`);
+        performance.mark(`${this.constructor.name}.write() start`);
+        await eslint_generated_types(parent_folder);
+        performance.measure(`${this.constructor.name}.write() eslint`, `${this.constructor.name}.write() start`);
+    }
+    async prepare() {
+        if (!this.prepared) {
+            this.prepared = true;
+            const discovery = await this.discovery;
+            const discovered_types = (await discovery.types_discovery.discover_types()).discovered_types;
+            discovery.add_candidates(new ObjectType(discovery), new ArrayType(discovered_types, discovery), new ExtendsObject(discovered_types, discovery), new typed_string(discovered_types, discovery), new oneOf_or_anyOf(discovery));
+        }
+    }
+    static can_class_have_tree(class_node) {
+        const heritage = [...(class_node.heritageClauses || [])].map((e) => e.types);
+        return (1 === heritage.length
+            && 1 === heritage[0].length
+            && ts.isExpressionWithTypeArguments(heritage[0][0])
+            && ts.isIdentifier(heritage[0][0].expression));
+    }
+}
+//# sourceMappingURL=TypeDefinitionWriter.js.map

package/lib/TypesDiscovery/CandidatesDiscovery.d.ts

@@ -0,0 +1,10 @@
+import { SchemaObject } from 'ajv/dist/2020';
+export declare abstract class CandidatesDiscovery {
+    protected readonly schema: SchemaObject;
+    constructor(schema: SchemaObject);
+    abstract discovery_candidates(current: unknown, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
+}
+export declare abstract class PropertyDependentDiscovery extends CandidatesDiscovery {
+    protected readonly property: string;
+    constructor(property: string, schema: SchemaObject);
+}

package/lib/TypesDiscovery/CandidatesDiscovery.js

@@ -0,0 +1,14 @@
+export class CandidatesDiscovery {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+}
+export class PropertyDependentDiscovery extends CandidatesDiscovery {
+    property;
+    constructor(property, schema) {
+        super(schema);
+        this.property = property;
+    }
+}
+//# sourceMappingURL=CandidatesDiscovery.js.map

package/lib/TypesDiscovery/CustomParsingTypes/UnrealEngineString.d.ts

@@ -0,0 +1,5 @@
+import { CandidatesDiscovery } from '../CandidatesDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+export declare class UnrealEngineString extends CandidatesDiscovery {
+    discovery_candidates(current: SchemaObject, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
+}