@satisfactory-dev/docs.json.ts 0.10.0 → 0.11.0

package/lib/DocsTsGenerator.js

@@ -5,14 +5,13 @@ 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' with {
-    type: 'json'
-};
 import { createHash, } from 'node:crypto';
 import { is_non_empty_array, is_string, object_has_only_properties_that_match_predicate, object_has_property, property_exists_on_object, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import { NoMatchError, } from './Exceptions';
 import { TypedString, } from './CustomParsingTypes/TypedString';
 import { compile, esmify, } from '@satisfactory-dev/ajv-utilities';
+import { DocsSchemaByVersion, } from './DocsSchema';
+import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export class ValidationError extends Error {
     errors;
@@ -23,11 +22,27 @@ export class ValidationError extends Error {
         this.json = json;
     }
 }
-export class DocsTsGenerator {
+export class DocsTsGeneratorVersion {
     docs;
     cache_path;
     docs_path;
+    // eslint-disable-next-line max-len
+    UnrealEngineString_quote_mode;
+    constructor({ 
+    // raw JSON or path to UTF-16LE encoded Docs.json
+    docs_path, 
+    // optional cache folder path for cacheable resources
+    cache_path = undefined, UnrealEngineString_quote_mode, }) {
+        this.cache_path = cache_path;
+        this.docs_path = docs_path;
+        this.UnrealEngineString_quote_mode = UnrealEngineString_quote_mode;
+    }
+}
+export class DocsTsGenerator {
+    // eslint-disable-next-line max-len
+    schema_data = new DocsSchemaByVersion();
     ajv;
+    docs_versions;
     types_from_module;
     static PERF_EARLY_RETURN = 'Early Return of Docs.json';
     static PERF_FAILURE = 'Failure to load Docs.json';
@@ -41,17 +56,17 @@ export class DocsTsGenerator {
     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, types_from_module = undefined, }) {
+    // Docs object
+    docs_versions, types_from_module = undefined, }) {
+        if (Object.keys(docs_versions).length < 1) {
+            throw new Error('No versions specified!');
+        }
         this.ajv = ajv;
-        this.docs_path = docs_path;
-        this.cache_path = cache_path;
+        this.docs_versions = docs_versions;
         this.types_from_module = types_from_module;
     }
-    async definition($ref) {
-        const schema = await this.schema();
+    async definition(version, $ref) {
+        const schema = await this.schema(version);
         if (!property_exists_on_object(schema.$defs, $ref)) {
             throw new NoMatchError({
                 $ref,
@@ -60,30 +75,53 @@ export class DocsTsGenerator {
         }
         return schema.$defs[$ref];
     }
-    async get() {
-        return this.validate(await this.load(), await this.schema());
+    async get(version) {
+        return this.validate(version, await this.load(version), await this.schema(version));
     }
-    async schema() {
-        await this.validate_schema(update8_schema);
-        return update8_schema;
+    schema(version) {
+        if ('update8' === version) {
+            return this.schema_update8();
+        }
+        else if ('version_1_0_0_0' === version) {
+            return this.schema_version_1_0_0_0();
+        }
+        throw new Error('Could not find specified schema!');
+    }
+    // eslint-disable-next-line max-len
+    async schema_update8() {
+        const schema = this.schema_data.update8.en_US.schema;
+        // eslint-disable-next-line max-len
+        await this.validate_schema('update8', schema);
+        return schema;
+    }
+    // eslint-disable-next-line max-len
+    async schema_version_1_0_0_0() {
+        const schema = this.schema_data.version_1_0_0_0.en_US.schema;
+        // eslint-disable-next-line max-len
+        await this.validate_schema('version_1_0_0_0', schema);
+        return schema;
     }
-    async load() {
-        if (undefined === this.docs) {
+    async load(version) {
+        const docs = this.docs_versions[version];
+        if (undefined === docs) {
+            throw new Error('Requested version not configured!');
+        }
+        if (undefined === docs.docs) {
             performance.mark(DocsTsGenerator.PERF_START_LOADING_JSON);
-            if ('string' !== typeof this.docs_path) {
+            if ('string' !== typeof docs.docs_path) {
                 performance.measure(DocsTsGenerator.PERF_EARLY_RETURN, DocsTsGenerator.PERF_START_LOADING_JSON);
-                return this.docs_path;
+                return docs.docs_path;
             }
-            else if (!this.docs_path.endsWith('.json')) {
+            else if (!docs.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 (docs.cache_path) {
+                        const utf8_filename = basename(docs.docs_path).replace(/\.json$/, '.utf8.json');
+                        const utf8_filepath = `${docs.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);
@@ -91,13 +129,13 @@ export class DocsTsGenerator {
                             performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
                         }
                         else {
-                            maybe_json = await this.load_from_file(this.docs_path);
+                            maybe_json = await this.load_from_file(docs.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);
+                        maybe_json = await this.load_from_file(docs.docs_path);
                         performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
                     }
                 }
@@ -109,13 +147,13 @@ export class DocsTsGenerator {
                     performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
                     throw new Error('Was expecting json to be an array!');
                 }
-                this.docs = maybe_json;
+                docs.docs = maybe_json;
             }
-            if (undefined === this.docs) {
-                throw new Error('this.docs not set!');
+            if (undefined === docs.docs) {
+                throw new Error('docs not set!');
             }
         }
-        return this.docs;
+        return docs.docs;
     }
     async load_from_file(filepath) {
         const file = await readFile(filepath, {
@@ -125,18 +163,22 @@ export class DocsTsGenerator {
         const utf8 = Buffer.from(file).toString('utf-8');
         return JSON.parse(utf8.trim());
     }
-    async validate(json, schema) {
+    async validate(version, json, schema) {
         performance.mark(DocsTsGenerator.PERF_VALIDATION_STARTED);
-        const validateDocs = await this.validate_schema(schema);
+        const validateDocs = await this.validate_schema(version, 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);
+            throw new ValidationError(`Failed to validate ${version} against the provided JSON Schema`, validateDocs.errors, json);
         }
         return json;
     }
-    async validate_schema(schema) {
+    async validate_schema(version, schema) {
+        const docs = this.docs_versions[version];
+        if (undefined === docs) {
+            throw new Error('Requested version not configured!');
+        }
         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;
@@ -144,17 +186,19 @@ export class DocsTsGenerator {
                 TypedString.instance().configure_ajv($defs, this.ajv);
             }
         }
-        if (this.cache_path) {
+        if (docs.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}`;
+            const filepath = `${docs.cache_path}/${filename}`;
             if (!existsSync(filepath)) {
                 performance.mark(DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
                 performance.measure('ajv configured', DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
+                // eslint-disable-next-line max-len
+                UnrealEngineString.quote_mode = docs.UnrealEngineString_quote_mode;
                 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);
             }
@@ -190,4 +234,3 @@ export async function eslint_generated_types(parent_folder) {
         rulesMeta: eslint.getRulesMetaForResults(results),
     })}\n`);
 }
-//# sourceMappingURL=DocsTsGenerator.js.map

package/lib/DocsValidation.js

@@ -178,4 +178,3 @@ export function configure_ajv(ajv) {
         },
     });
 }
-//# sourceMappingURL=DocsValidation.js.map

package/lib/Exceptions.js

@@ -10,4 +10,3 @@ export class FragileTypeSafetyError extends NoMatchError {
         super(property, 'type safety in here is a bit fragile, check earlier in the stack');
     }
 }
-//# sourceMappingURL=Exceptions.js.map

package/lib/FilesGenerator.js

@@ -45,4 +45,3 @@ export function guess_filename(ref) {
     }
     return 'common/unassigned.ts';
 }
-//# sourceMappingURL=FilesGenerator.js.map

package/lib/MarkdownUtilities.js

@@ -65,4 +65,3 @@ export function remove_indentation(input) {
     }
     return str;
 }
-//# sourceMappingURL=MarkdownUtilities.js.map

package/lib/StringStartsWith.js

@@ -15,4 +15,3 @@ export function is_$ref(maybe) {
 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

@@ -39,7 +39,7 @@ declare const type_map: {
     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 create_object_type_from_entries(entries: [string, TypeNode][], required?: [string, ...string[]], default_required?: boolean): 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;

package/lib/TsFactoryWrapper.js

@@ -7,7 +7,7 @@ export function adjust_class_name(class_name) {
     if ('class' === class_name) {
         return 'Docs_class';
     }
-    return class_name.replace(/[^A-Za-z_\d]/g, '_');
+    return class_name.replace(/[^A-Za-z_\d ]/g, '_');
 }
 export const modifier_map = {
     abstract: () => {
@@ -130,10 +130,10 @@ const type_map = {
 export function create_type(type) {
     return ts.factory.createKeywordTypeNode(type_map[type]);
 }
-export function create_object_type_from_entries(entries, required) {
+export function create_object_type_from_entries(entries, required, default_required = true) {
     return ts.factory.createTypeLiteralNode(entries.map((entry) => {
         const [property, type] = entry;
-        return createPropertySignature(property, type, required ? required.includes(property) : true);
+        return createPropertySignature(property, type, required ? required.includes(property) : default_required);
     }));
 }
 export function createPropertySignature(property, type, required = true) {
@@ -142,7 +142,7 @@ export function createPropertySignature(property, type, required = true) {
         : ts.factory.createToken(ts.SyntaxKind.QuestionToken), type);
 }
 export function needs_element_access(property) {
-    return /[?[\]]/.test(property);
+    return /[?[\] ]/.test(property);
 }
 export function computed_property_name_or_undefined(property) {
     return needs_element_access(property)
@@ -232,4 +232,3 @@ export function variable(name, value, type = undefined) {
 export function not(expression) {
     return ts.factory.createLogicalNot(expression);
 }
-//# sourceMappingURL=TsFactoryWrapper.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -1,5 +1,5 @@
 import { Generator, } from '../Generator';
-import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
+import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_regex_quoted, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
 export class UnrealEngineString extends Generator {
     constructor(ajv) {
         super(ajv, {
@@ -13,7 +13,10 @@ export class UnrealEngineString extends Generator {
         };
     }
     static fromString(value) {
-        const result = UnrealEngineString_regex.exec(value);
+        let result = UnrealEngineString_regex.exec(value);
+        if (!result) {
+            result = UnrealEngineString_regex_quoted.exec(value);
+        }
         if (!result) {
             throw new Error(`Not an UnrealEngineString (${value})`);
         }
@@ -23,4 +26,3 @@ export class UnrealEngineString extends Generator {
         };
     }
 }
-//# sourceMappingURL=UnrealEngineString.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.js

@@ -17,4 +17,3 @@ export class string_starts_with extends Generator {
         return (raw_data) => type_reference_node('StringStartsWith', create_literal(raw_data.string_starts_with));
     }
 }
-//# sourceMappingURL=string_starts_with.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.d.ts

@@ -1,14 +1,14 @@
 import { TupleTypeNode, TypeLiteralNode, UnionTypeNode } from 'typescript';
 import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
 import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
-import { typed_string_inner_array_prefixItems_type, typed_string_inner_array_type, typed_string_inner_object_pattern_type, typed_string_inner_object_type, typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
+import { typed_string_inner_array_prefixItems_type, typed_string_inner_array_type, typed_string_inner_object_pattern_type, typed_string_inner_object_type, typed_string_inner_object_type_no_required, typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
 import { local_ref } from '../../StringStartsWith';
 export declare class typed_string extends GeneratorDoesDiscovery<typed_string_parent_type, TypeLiteralNode | TupleTypeNode | UnionTypeNode> {
     private readonly known_types;
     constructor(supported_refs: local_ref<string>[], discovery: TypeDefinitionDiscovery);
     generate(): (raw_data: typed_string_parent_type) => TypeLiteralNode | TupleTypeNode | UnionTypeNode;
-    static is_array_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_type;
-    static is_object_pattern_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_object_pattern_type;
-    static is_object_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_object_type;
-    static is_prefixItems_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_prefixItems_type;
+    static is_array_type(maybe: typed_string_inner_object_type_no_required | typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_type;
+    static is_object_pattern_type(maybe: typed_string_inner_object_type_no_required | typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_object_pattern_type;
+    static is_object_type(maybe: typed_string_inner_object_type_no_required | typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is (typed_string_inner_object_type | typed_string_inner_object_type_no_required);
+    static is_prefixItems_type(maybe: typed_string_inner_object_type_no_required | typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_prefixItems_type;
 }

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js

@@ -76,7 +76,9 @@ export class typed_string extends GeneratorDoesDiscovery {
                     entry[0],
                     this.discovery.find(entry[1]),
                 ];
-            }), typed_string_value.required);
+            }), ('required' in typed_string_value
+                ? typed_string_value.required
+                : undefined), false);
         };
     }
     static is_array_type(maybe) {
@@ -93,4 +95,3 @@ export class typed_string extends GeneratorDoesDiscovery {
         return object_has_property(maybe, 'prefixItems');
     }
 }
-//# sourceMappingURL=typed_string.js.map

package/lib/TypeDefinitionDiscovery/Generator.js

@@ -5,4 +5,3 @@ export class Generator {
         this.check = compile(ajv, schema);
     }
 }
-//# sourceMappingURL=Generator.js.map

package/lib/TypeDefinitionDiscovery/GeneratorDoesDiscovery.js

@@ -6,4 +6,3 @@ export class GeneratorDoesDiscovery extends Generator {
         this.discovery = discovery;
     }
 }
-//# sourceMappingURL=GeneratorDoesDiscovery.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/ArrayType.js

@@ -58,4 +58,3 @@ export class ArrayType extends GeneratorDoesDiscovery {
         };
     }
 }
-//# sourceMappingURL=ArrayType.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject.js

@@ -37,4 +37,3 @@ export class ExtendsObject extends GeneratorDoesDiscovery {
         return ts.factory.createTypeReferenceNode(adjust_class_name(`${$ref.substring(8)}__type`));
     }
 }
-//# sourceMappingURL=ExtendsObject.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/ObjectType.js

@@ -73,4 +73,3 @@ export class ObjectType extends GeneratorDoesDiscovery {
         };
     }
 }
-//# sourceMappingURL=ObjectType.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Const.js

@@ -17,4 +17,3 @@ export class Const extends Generator {
         return (raw_data) => create_literal(raw_data.const);
     }
 }
-//# sourceMappingURL=Const.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum.js

@@ -44,4 +44,3 @@ export class BooleanEnum extends Generator {
         };
     }
 }
-//# sourceMappingURL=BooleanEnum.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum.js

@@ -19,4 +19,3 @@ export class Enum extends Generator {
         };
     }
 }
-//# sourceMappingURL=Enum.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Pattern.js

@@ -18,4 +18,3 @@ export class Pattern extends Generator {
         };
     }
 }
-//# sourceMappingURL=Pattern.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String.js

@@ -69,4 +69,3 @@ export class NonEmptyStringWithExclusions extends Generator {
         ]));
     }
 }
-//# sourceMappingURL=String.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf.js

@@ -44,4 +44,3 @@ export class oneOf_or_anyOf extends GeneratorDoesDiscovery {
         };
     }
 }
-//# sourceMappingURL=oneOf_or_anyOf.js.map

package/lib/TypeDefinitionDiscovery.d.ts

@@ -4,7 +4,7 @@ import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
 import ts, { TypeNode } from 'typescript';
 import { AnyGenerator } from './TypeDefinitionDiscovery/Generator';
 import { FilesGenerator } from './FilesGenerator';
-import { DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
 import { GeneratesMarkdown } from './MarkdownUtilities';
 export type ref_discovery_type = {
     found_types: {
@@ -21,6 +21,7 @@ export type ref_discovery_type = {
 export declare class TypeDefinitionDiscovery extends FilesGenerator implements GeneratesMarkdown {
     private $ref_discovery;
     private readonly candidates;
+    private readonly version;
     readonly docs: DocsTsGenerator;
     readonly types_discovery: TypesDiscovery;
     constructor(types_discovery: [
@@ -29,7 +30,7 @@ export declare class TypeDefinitionDiscovery extends FilesGenerator implements G
     ], type_definition_discover: [
         AnyGenerator,
         ...AnyGenerator[]
-    ], docs: DocsTsGenerator);
+    ], docs: DocsTsGenerator, version: keyof docs_versions);
     add_candidates(...candidates: AnyGenerator[]): void;
     discover_type_$defs(): Promise<ref_discovery_type>;
     find(maybe: unknown): TypeNode;

package/lib/TypeDefinitionDiscovery.js

@@ -28,13 +28,15 @@ function is_schema_with_$defs(schema, discovered_types) {
 export class TypeDefinitionDiscovery extends FilesGenerator {
     $ref_discovery;
     candidates;
+    version;
     docs;
     types_discovery;
-    constructor(types_discovery, type_definition_discover, docs) {
+    constructor(types_discovery, type_definition_discover, docs, version) {
         super();
-        this.types_discovery = new TypesDiscovery(types_discovery, docs);
+        this.types_discovery = new TypesDiscovery(types_discovery, docs, version);
         this.candidates = type_definition_discover;
         this.docs = docs;
+        this.version = version;
     }
     add_candidates(...candidates) {
         this.candidates.push(...candidates);
@@ -69,7 +71,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
             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))),
+                node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), adjust_class_name(`${$ref}__type`), undefined, generator(await this.docs.definition(this.version, $ref))),
             };
         }
     }
@@ -177,7 +179,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         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'],
+                required: ['$comment', 'type', '$ref', 'properties'],
                 additionalProperties: false,
                 $defs: {
                     $ref_base: {
@@ -209,6 +211,11 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                     },
                 },
                 properties: {
+                    $comment: {
+                        type: 'string',
+                        // eslint-disable-next-line max-len
+                        pattern: '^\\/Script\\/CoreUObject\\.Class\'\\/Script\\/FactoryGame\\.',
+                    },
                     type: { type: 'string', const: 'object' },
                     $ref: { type: 'string', const: '#/$defs/NativeClass' },
                     unevaluatedProperties: { type: 'boolean', const: false },
@@ -313,12 +320,49 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                                             },
                                         },
                                     },
+                                    {
+                                        type: 'object',
+                                        required: [
+                                            'type',
+                                            'prefixItems',
+                                            'minItems',
+                                        ],
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                const: 'array',
+                                            },
+                                            minItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            maxItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            items: {
+                                                type: 'boolean',
+                                                const: false,
+                                            },
+                                            prefixItems: {
+                                                type: 'array',
+                                                minItems: 1,
+                                                items: {
+                                                    $ref: '#/$defs/$ref',
+                                                },
+                                            },
+                                        },
+                                    },
                                 ] } },
                     },
                 },
             });
             for (const item of schema.prefixItems) {
                 if (native_class(item)) {
+                    if ('$comment' in item) {
+                        delete item.$comment;
+                    }
                     result.found_classes.push(item);
                 }
                 else {
@@ -338,7 +382,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
      * @todo move to DocsTsGenerator
      */
     async schema_from_json(discovered_types) {
-        const schema = await this.docs.schema();
+        const schema = await this.docs.schema(this.version);
         if (!is_schema_with_$defs(schema, discovered_types)) {
             throw new Error('Schema $defs not as expected!');
         }
@@ -372,4 +416,3 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         ];
     }
 }
-//# sourceMappingURL=TypeDefinitionDiscovery.js.map

package/lib/TypeDefinitionWriter.d.ts

@@ -1,6 +1,6 @@
 import { TypeDefinitionDiscovery } from './TypeDefinitionDiscovery';
 import ts, { ClassDeclaration } from 'typescript';
-import { DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
 type class_can_have_tree = ClassDeclaration & {
     heritageClauses: [{
         types: [{
@@ -13,7 +13,8 @@ export declare class TypeDefinitionWriter {
     private prepared;
     private readonly data_discovery;
     private readonly docs;
-    constructor(docs: DocsTsGenerator);
+    private readonly version;
+    constructor(docs: DocsTsGenerator, version: keyof docs_versions);
     get discovery(): Promise<TypeDefinitionDiscovery>;
     write(parent_folder: string, cleanup?: boolean): Promise<void>;
     private prepare;