@satisfactory-dev/docs.json.ts 0.16.0 → 0.17.0

package/lib/DocsTsGenerator.js

@@ -1,19 +1,17 @@
 import { readFile, writeFile, } from 'node:fs/promises';
-import { basename, dirname, } from 'node:path';
+import { basename, } 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 standalone from 'ajv/dist/standalone/index.js';
 import { ESLint, } from 'eslint';
 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 { NoMatchError, } from "./Exceptions.js";
+import { TypedString, } from "./CustomParsingTypes/TypedString.js";
 import { compile, esmify, } from '@satisfactory-dev/ajv-utilities';
-import { DocsSchemaByVersion, } from './DocsSchema';
-import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
+import { DocsSchemaByVersion, } from "./DocsSchema.js";
+import { UnrealEngineString, } from "./CustomParsingTypes/UnrealEngineString.js";
 import common_schema from '../schema/common.schema.json' with { type: 'json' };
-const __dirname = dirname(fileURLToPath(import.meta.url));
 export class ValidationError extends Error {
     errors;
     json;
@@ -29,7 +27,6 @@ export class DocsTsGeneratorVersion {
     common_types_from_module;
     docs_path;
     types_from_module;
-    // eslint-disable-next-line max-len
     UnrealEngineString_quote_mode;
     constructor({ 
     // raw JSON or path to UTF-16LE encoded Docs.json
@@ -44,7 +41,7 @@ export class DocsTsGeneratorVersion {
     }
 }
 export class DocsTsGenerator {
-    // eslint-disable-next-line max-len
+    // eslint-disable-next-line @stylistic/max-len
     schema_data = new DocsSchemaByVersion();
     ajv;
     docs_versions;
@@ -55,7 +52,7 @@ export class DocsTsGenerator {
     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_PRECOMPILE = ('Docs.json validation pre-compilation started');
     static PERF_VALIDATION_STARTED = 'Docs.json validation started';
     constructor({ 
     // Ajv instance
@@ -91,8 +88,8 @@ export class DocsTsGenerator {
         if ('update8' === version) {
             return this.schema_update8();
         }
-        else if ('version_1_1_1_0' === version) {
-            return this.schema_version_1_1_1_0();
+        else if ('version_1_1_1_1' === version) {
+            return this.schema_version_1_1_1_1();
         }
         else if ('version_1_0_1_4' === version) {
             return this.schema_version_1_0_1_4();
@@ -102,37 +99,32 @@ export class DocsTsGenerator {
         }
         throw new Error('Could not find specified schema!');
     }
-    // eslint-disable-next-line max-len
     async schema_common() {
         const schema = this.schema_data.common.en_US.schema;
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/max-len
         await this.validate_schema('common', schema);
         return 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
+        // eslint-disable-next-line @stylistic/max-len
         await this.validate_schema('update8', schema);
         return schema;
     }
-    // eslint-disable-next-line max-len
     async schema_version_1_0_1_4() {
         const schema = this.schema_data.version_1_0_1_4.en_US.schema;
-        // eslint-disable-next-line max-len
         await this.validate_schema('version_1_0_1_4', schema);
         return schema;
     }
-    // eslint-disable-next-line max-len
-    async schema_version_1_1_1_0() {
-        const schema = this.schema_data.version_1_1_1_0.en_US.schema;
+    async schema_version_1_1_1_1() {
+        const schema = this.schema_data.version_1_1_1_1.en_US.schema;
         /*
         const schema_1_0 = await this.schema_version_1_0_1_4();
         this.ajv.removeSchema('1.0.schema.json');
         this.ajv.addSchema(schema_1_0);
         */
-        // eslint-disable-next-line max-len
-        await this.validate_schema('version_1_1_1_0', schema);
+        // eslint-disable-next-line @stylistic/max-len
+        await this.validate_schema('version_1_1_1_1', schema);
         return schema;
     }
     async load(version) {
@@ -229,24 +221,24 @@ export class DocsTsGenerator {
             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']}`));
+            file_sha512.update(await readFile(`${import.meta.dirname}/../schema/${schema['$id']}`));
             const filename = `${schema['$id']}.${file_sha512.digest('hex')}.mjs`;
             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
+                // eslint-disable-next-line @stylistic/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);
             }
-            const { default: validateDocs, } = (await import(filepath));
+            const { default: validateDocs, } = (await import(__rewriteRelativeImportExtension(filepath)));
             return validateDocs;
         }
         return compile(this.ajv, schema);
     }
 }
-const prettier_config = prettier.resolveConfig(`${__dirname}/../.prettierrc`);
+const prettier_config = prettier.resolveConfig(`${import.meta.dirname}/../.prettierrc`);
 export async function format_code(code, parser = 'typescript') {
     const config = await prettier_config;
     if (!config) {
@@ -267,8 +259,5 @@ export async function eslint_generated_types(parent_folder) {
     });
     const eslint_formatter = eslint.loadFormatter('stylish');
     const results = await eslint.lintFiles(`${parent_folder}/**/*.ts`);
-    process.stdout.write(`${await (await eslint_formatter).format(results, {
-        cwd: parent_folder,
-        rulesMeta: eslint.getRulesMetaForResults(results),
-    })}\n`);
+    process.stdout.write(`${await (await eslint_formatter).format(results)}\n`);
 }

package/lib/DocsValidation.d.ts

@@ -1,4 +1,4 @@
-import Ajv from 'ajv/dist/2020';
+import type Ajv from 'ajv/dist/2020.js';
 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;

package/lib/DocsValidation.js

@@ -1,5 +1,5 @@
-import { _, } from 'ajv/dist/2020';
-import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
+import { _, } from 'ajv/dist/2020.js';
+import { UnrealEngineString, } from "./CustomParsingTypes/UnrealEngineString.js";
 import { is_string, } from '@satisfactory-dev/predicates.ts';
 import common_schema from '../schema/common.schema.json' with { type: 'json' };
 export function string_to_native_type(data, shallow = false) {
@@ -17,8 +17,8 @@ export function string_to_object(data, shallow = false) {
     if ('' === data) {
         return false;
     }
-    const match = /^\([^=]+=([^,]+|\([^)]+\))(,[^=]+=(\([^)]+)\)|,[^=]+=[^,]+)*\)$/
-        .test(data);
+    const match = (/^\([^=]+=([^,]+|\([^)]+\))(,[^=]+=(\([^)]+)\)|,[^=]+=[^,]+)*\)$/
+        .test(data));
     if (!match) {
         return false;
     }
@@ -46,8 +46,7 @@ export function string_to_object(data, shallow = false) {
             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);
+                    was.current_value_buffer = (was.current_value_buffer.substring(1, was.current_value_buffer.length - 1));
                 }
                 const coerced_value = shallow
                     ? was.current_value_buffer
@@ -76,9 +75,8 @@ export function string_to_object(data, shallow = false) {
             if ('' !== was.current_key_buffer) {
                 const coerced_value = shallow
                     ? (/^".+"$/.test(was.current_value_buffer)
-                        ? was.current_value_buffer.substring(1, 
-                        // eslint-disable-next-line max-len
-                        was.current_value_buffer.length - 1)
+                        ? 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([

package/lib/FilesGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Node } from 'typescript';
+import type { Node } from 'typescript';
 export type entry = {
     file: string;
     node: Node;
@@ -14,6 +14,6 @@ export declare abstract class FilesGenerator {
 export declare class FromArray extends FilesGenerator {
     private readonly entries;
     constructor(entries: [entry, ...entry[]]);
-    generate_files(): AsyncGenerator<entry, void, undefined>;
+    generate_files(): AsyncGenerator<entry, void, unknown>;
 }
 export declare function guess_filename(ref: string): string;

package/lib/StringStartsWith.js

@@ -1,5 +1,5 @@
 import { is_string, } from '@satisfactory-dev/predicates.ts';
-import { NoMatchError, } from './Exceptions';
+import { NoMatchError, } from "./Exceptions.js";
 export function local_ref(ref_like_string) {
     if (/\s+/.test(ref_like_string)) {
         throw new Error('No spacing characters allowed!');

package/lib/TsFactoryWrapper.d.ts

@@ -1,6 +1,7 @@
-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';
+import type { ClassDeclaration, Expression, KeywordTypeSyntaxKind, LiteralTypeNode, MethodDeclaration, ModifierSyntaxKind, ModifierToken, NodeArray, NullLiteral, ParenthesizedExpression, PrefixUnaryExpression, PropertyDeclaration, PropertySignature, RegularExpressionLiteral, StringLiteral, SyntaxKind, TemplateExpression, TypeLiteralNode, TypeNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement } from 'typescript';
+import ts from 'typescript';
 declare type supported_class_modifiers = ('export' | 'abstract')[];
-declare type supported_modifier = 'abstract' | 'protected' | 'public' | 'static';
+declare type supported_modifier = ('abstract' | 'protected' | 'public' | 'static');
 declare type supported_method_modifiers = [
     supported_modifier,
     ...supported_modifier[]
@@ -10,7 +11,7 @@ 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 create_modifiers(first: modifier, ...rest: modifier[]): [ModifierToken<ModifierSyntaxKind>, ...ModifierToken<ModifierSyntaxKind>[]];
 export declare function type_reference_node(name: string, ...type_arguments: TypeNode[]): TypeReferenceNode;
 export type create_class_options = {
     modifiers?: supported_class_modifiers;
@@ -18,25 +19,25 @@ export type create_class_options = {
 };
 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;
+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;
+], parameters: createMethod_parameters_entry[], body: ts.Statement[], modifiers: supported_method_modifiers, return_type?: ts.TypeNode | undefined): 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): 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;
+    boolean: SyntaxKind;
+    number: SyntaxKind;
+    object: SyntaxKind;
+    string: SyntaxKind;
+    undefined: SyntaxKind;
+    never: SyntaxKind;
+    unknown: 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[]], default_required?: boolean): TypeLiteralNode;
@@ -53,7 +54,7 @@ export declare function create_literal<T1 extends string | RegExp | null = strin
     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 | {
+declare type lazy_union_item = (string | {
     $ref: string;
 } | ({
     type: string;
@@ -61,7 +62,7 @@ declare type lazy_union_item = 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 & {

package/lib/TsFactoryWrapper.js

@@ -46,7 +46,7 @@ export function create_modifiers(first, ...rest) {
         }
         return was;
     }, [first]);
-    return non_empty_map(modifiers, e => modifier_map[e]());
+    return non_empty_map(modifiers, (e) => modifier_map[e]());
 }
 export function type_reference_node(name, ...type_arguments) {
     return ts.factory.createTypeReferenceNode(name, type_arguments);

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

@@ -1,7 +1,7 @@
-import { Generator } from '../Generator';
-import { UnrealEngineString_parent_type, UnrealEngineString_type } from '../../CustomParsingTypes/UnrealEngineString';
-import { TypeReferenceNode } from 'typescript';
-import Ajv from 'ajv/dist/2020';
+import { Generator } from '../Generator.ts';
+import type { UnrealEngineString_parent_type, UnrealEngineString_type } from '../../CustomParsingTypes/UnrealEngineString.ts';
+import type { TypeReferenceNode } from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
 export type UnrealEngineString_left_right<left extends string = string, right extends string = string> = (Exclude<UnrealEngineString_type, true> & {
     left: left;
     right: right;

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -1,5 +1,5 @@
-import { Generator, } from '../Generator';
-import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_regex_quoted, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
+import { Generator, } from "../Generator.js";
+import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_regex_quoted, UnrealEngineString_schema_definitions, } from "../../CustomParsingTypes/UnrealEngineString.js";
 export class UnrealEngineString extends Generator {
     constructor(ajv) {
         super(ajv, {

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

@@ -1,6 +1,6 @@
-import { Generator } from '../Generator';
-import { TypeReferenceNode } from 'typescript';
-import Ajv from 'ajv/dist/2020';
+import { Generator } from '../Generator.ts';
+import type { TypeReferenceNode } from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
 export type RawData = {
     type: 'string';
     string_starts_with: string;

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.js

@@ -1,5 +1,5 @@
-import { Generator, } from '../Generator';
-import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
+import { Generator, } from "../Generator.js";
+import { create_literal, type_reference_node, } from "../../TsFactoryWrapper.js";
 export const schema = {
     type: 'object',
     required: ['type', 'string_starts_with'],

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

@@ -1,8 +1,8 @@
-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_inner_object_type_no_required, typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
-import { common_ref, local_ref } from '../../StringStartsWith';
+import type { TupleTypeNode, TypeLiteralNode, UnionTypeNode } from 'typescript';
+import type { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery.ts';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery.ts';
+import type { 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.ts';
+import type { common_ref, local_ref } from '../../StringStartsWith.ts';
 export declare class typed_string extends GeneratorDoesDiscovery<typed_string_parent_type, TypeLiteralNode | TupleTypeNode | UnionTypeNode> {
     private readonly known_types;
     constructor(supported_refs: local_ref<string>[], supported_common_refs: common_ref<string>[], discovery: TypeDefinitionDiscovery);

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js

@@ -1,8 +1,8 @@
 import ts from 'typescript';
-import { create_object_type_from_entries, createPropertySignature, minimum_size_array_of_single_type, } from '../../TsFactoryWrapper';
-import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
-import { UnrealEngineString, } from './UnrealEngineString';
-import { generate_object_parent_schema, generate_typed_string_$defs, } from '../../CustomParsingTypes/TypedString';
+import { create_object_type_from_entries, createPropertySignature, minimum_size_array_of_single_type, } from "../../TsFactoryWrapper.js";
+import { GeneratorDoesDiscovery, } from "../GeneratorDoesDiscovery.js";
+import { UnrealEngineString, } from "./UnrealEngineString.js";
+import { generate_object_parent_schema, generate_typed_string_$defs, } from "../../CustomParsingTypes/TypedString.js";
 import { object_has_property, } from '@satisfactory-dev/predicates.ts';
 function create_combinations(values) {
     const as_array = [...values.values()];
@@ -51,7 +51,7 @@ export class typed_string extends GeneratorDoesDiscovery {
                 return minimum_size_array_of_single_type(typed_string_value.minItems, () => this.discovery.find(typed_string_value.items), typed_string_value.maxItems);
             }
             else if (typed_string.is_prefixItems_type(typed_string_value)) {
-                return minimum_size_array_of_single_type(typed_string_value.minItems, () => ts.factory.createTupleTypeNode(typed_string_value.prefixItems.map(e => this.discovery.find(e))), typed_string_value.maxItems);
+                return minimum_size_array_of_single_type(typed_string_value.minItems, () => ts.factory.createTupleTypeNode(typed_string_value.prefixItems.map((e) => this.discovery.find(e))), typed_string_value.maxItems);
             }
             else if (typed_string.is_object_pattern_type(typed_string_value)) {
                 const [property_regex, value,] = Object.entries(typed_string_value.patternProperties)[0];
@@ -59,7 +59,7 @@ export class typed_string extends GeneratorDoesDiscovery {
                 const combinations = create_combinations(new Set(properties));
                 const value_generator = () => this.discovery.find(value);
                 const result = combinations.map((required) => {
-                    return ts.factory.createTypeLiteralNode(required.map(property => createPropertySignature(property, value_generator())));
+                    return ts.factory.createTypeLiteralNode(required.map((property) => createPropertySignature(property, value_generator())));
                 });
                 return ts.factory.createUnionTypeNode(result);
             }

package/lib/TypeDefinitionDiscovery/Generator.d.ts

@@ -1,5 +1,6 @@
-import Ajv, { SchemaObject, ValidateFunction } from 'ajv/dist/2020';
-import { TypeNode } from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
+import type { SchemaObject, ValidateFunction } from 'ajv/dist/2020.js';
+import type { TypeNode } from 'typescript';
 export type AnyGenerator = Generator<any>;
 export declare abstract class Generator<RawData, Type extends TypeNode = TypeNode> {
     readonly check: ValidateFunction<RawData>;

package/lib/TypeDefinitionDiscovery/GeneratorDoesDiscovery.d.ts

@@ -1,7 +1,7 @@
-import { TypeNode } from 'typescript';
-import { Generator } from './Generator';
-import { TypeDefinitionDiscovery } from '../TypeDefinitionDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import type { TypeNode } from 'typescript';
+import { Generator } from './Generator.ts';
+import type { TypeDefinitionDiscovery } from '../TypeDefinitionDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare abstract class GeneratorDoesDiscovery<RawData, Type extends TypeNode = TypeNode> extends Generator<RawData, Type> {
     protected readonly discovery: TypeDefinitionDiscovery;
     protected constructor(schema: SchemaObject, discovery: TypeDefinitionDiscovery);

package/lib/TypeDefinitionDiscovery/GeneratorDoesDiscovery.js

@@ -1,4 +1,4 @@
-import { Generator, } from './Generator';
+import { Generator, } from "./Generator.js";
 export class GeneratorDoesDiscovery extends Generator {
     discovery;
     constructor(schema, discovery) {

package/lib/TypeDefinitionDiscovery/JsonSchema/ArrayType.d.ts

@@ -1,6 +1,6 @@
-import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
-import ts, { ArrayTypeNode, TupleTypeNode } from 'typescript';
-import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery.ts';
+import type { ArrayTypeNode, TupleTypeNode } from 'typescript';
+import type { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery.ts';
 type RawData = {
     type: 'array';
     minItems?: 1;
@@ -14,6 +14,6 @@ type RawData = {
 };
 export declare class ArrayType extends GeneratorDoesDiscovery<RawData, TupleTypeNode | ArrayTypeNode> {
     constructor(supported_refs: string[], discovery: TypeDefinitionDiscovery);
-    generate(): (raw_data: RawData) => ts.ArrayTypeNode | ts.TupleTypeNode;
+    generate(): (raw_data: RawData) => ArrayTypeNode | TupleTypeNode;
 }
 export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/ArrayType.js

@@ -1,8 +1,8 @@
-import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { GeneratorDoesDiscovery, } from "../GeneratorDoesDiscovery.js";
 import ts from 'typescript';
 import { object_has_non_empty_array_property, object_has_property, } from '@satisfactory-dev/predicates.ts';
-import { minimum_size_array_of_single_type, } from '../../TsFactoryWrapper';
-import { NoMatchError, } from '../../Exceptions';
+import { minimum_size_array_of_single_type, } from "../../TsFactoryWrapper.js";
+import { NoMatchError, } from "../../Exceptions.js";
 export class ArrayType extends GeneratorDoesDiscovery {
     constructor(supported_refs, discovery) {
         super({
@@ -49,7 +49,7 @@ export class ArrayType extends GeneratorDoesDiscovery {
                 if (!object_has_non_empty_array_property(raw_data, 'prefixItems')) {
                     throw new NoMatchError(raw_data, 'Must specify prefixItems when items is false!');
                 }
-                return ts.factory.createTupleTypeNode(raw_data.prefixItems.map(e => this.discovery.find(e)));
+                return ts.factory.createTupleTypeNode(raw_data.prefixItems.map((e) => this.discovery.find(e)));
             }
             if (object_has_property(raw_data, 'minItems')) {
                 return minimum_size_array_of_single_type(raw_data.minItems, () => this.discovery.find(raw_data.items), raw_data.maxItems);

package/lib/TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject.d.ts

@@ -1,20 +1,20 @@
-import { IntersectionTypeNode, LiteralTypeNode, TypeReferenceNode } from 'typescript';
-import { RawData as ObjectTypeRawData } from '../ObjectType';
-import { TypeDefinitionDiscovery } from '../../../TypeDefinitionDiscovery';
-import { GeneratorDoesDiscovery } from '../../GeneratorDoesDiscovery';
-import { common_ref, local_ref } from '../../../StringStartsWith';
-type RawData = ObjectTypeRawData & {
+import type { IntersectionTypeNode, LiteralTypeNode, TypeReferenceNode } from 'typescript';
+import type { RawData as ObjectTypeRawData } from '../ObjectType.ts';
+import type { TypeDefinitionDiscovery } from '../../../TypeDefinitionDiscovery.ts';
+import { GeneratorDoesDiscovery } from '../../GeneratorDoesDiscovery.ts';
+import type { common_ref, local_ref } from '../../../StringStartsWith.ts';
+type RawData = (ObjectTypeRawData & {
     properties: {
         [key: string]: unknown;
     };
     $ref: local_ref<string>;
-};
-type Type = TypeReferenceNode | (IntersectionTypeNode & {
+});
+type Type = (TypeReferenceNode | (IntersectionTypeNode & {
     types: [
         TypeReferenceNode,
         LiteralTypeNode
     ];
-});
+}));
 export declare class ExtendsObject extends GeneratorDoesDiscovery<RawData, Type> {
     constructor(supported_refs: string[], common_supported_refs: string[], discovery: TypeDefinitionDiscovery);
     generate(): (raw_data: RawData) => Type;

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
-import { schema as ObjectTypeSchema, } from '../ObjectType';
-import { adjust_class_name, } from '../../../TsFactoryWrapper';
-import { GeneratorDoesDiscovery, } from '../../GeneratorDoesDiscovery';
+import { schema as ObjectTypeSchema, } from "../ObjectType.js";
+import { adjust_class_name, } from "../../../TsFactoryWrapper.js";
+import { GeneratorDoesDiscovery, } from "../../GeneratorDoesDiscovery.js";
 export class ExtendsObject extends GeneratorDoesDiscovery {
     constructor(supported_refs, common_supported_refs, discovery) {
         const { type, additionalProperties, properties, ...rest } = ObjectTypeSchema;

package/lib/TypeDefinitionDiscovery/JsonSchema/ObjectType.d.ts

@@ -1,6 +1,6 @@
-import { IntersectionTypeNode, TypeLiteralNode, TypeReferenceNode } from 'typescript';
-import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
-import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
+import type { IntersectionTypeNode, TypeLiteralNode, TypeReferenceNode } from 'typescript';
+import type { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery.ts';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery.ts';
 export type RawData = {
     type: 'object';
     required?: [string, ...string[]];

package/lib/TypeDefinitionDiscovery/JsonSchema/ObjectType.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { adjust_class_name, create_object_type_from_entries, type_reference_node, } from '../../TsFactoryWrapper';
-import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { adjust_class_name, create_object_type_from_entries, type_reference_node, } from "../../TsFactoryWrapper.js";
+import { GeneratorDoesDiscovery, } from "../GeneratorDoesDiscovery.js";
 import { is_string, } from '@satisfactory-dev/predicates.ts';
 export const schema = {
     type: 'object',

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Const.d.ts

@@ -1,6 +1,6 @@
-import Ajv from 'ajv/dist/2020';
-import { LiteralTypeNode, StringLiteral } from 'typescript';
-import { Generator } from '../../Generator';
+import type Ajv from 'ajv/dist/2020.js';
+import type { LiteralTypeNode, StringLiteral } from 'typescript';
+import { Generator } from '../../Generator.ts';
 type RawData = {
     type: 'string';
     const: string;

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

@@ -1,5 +1,5 @@
-import { create_literal, } from '../../../TsFactoryWrapper';
-import { Generator, } from '../../Generator';
+import { create_literal, } from "../../../TsFactoryWrapper.js";
+import { Generator, } from "../../Generator.js";
 export const schema = {
     type: 'object',
     required: ['type', 'const'],

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum.d.ts

@@ -1,6 +1,7 @@
-import { Generator } from '../../../Generator';
-import ts, { KeywordTypeNode, UnionTypeNode } from 'typescript';
-import Ajv from 'ajv/dist/2020';
+import { Generator } from '../../../Generator.ts';
+import type { KeywordTypeNode, UnionTypeNode } from 'typescript';
+import ts from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
 export type boolean_or_null_type = {
     type: 'string';
     enum: ['True', 'False'];
@@ -8,7 +9,7 @@ export type boolean_or_null_type = {
     type: 'string';
     enum: ['True', 'False', ''];
 };
-type boolean_or_null_return = KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | UnionTypeNode;
+type boolean_or_null_return = (KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | UnionTypeNode);
 export declare class BooleanEnum extends Generator<boolean_or_null_type, KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | UnionTypeNode> {
     constructor(ajv: Ajv);
     generate(): (raw_data: boolean_or_null_type) => boolean_or_null_return;

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

@@ -1,6 +1,6 @@
-import { Generator, } from '../../../Generator';
+import { Generator, } from "../../../Generator.js";
 import ts from 'typescript';
-import { create_literal, create_union, } from '../../../../TsFactoryWrapper';
+import { create_literal, create_union, } from "../../../../TsFactoryWrapper.js";
 export class BooleanEnum extends Generator {
     constructor(ajv) {
         super(ajv, {

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum.d.ts

@@ -1,6 +1,6 @@
-import { Generator } from '../../Generator';
-import Ajv from 'ajv/dist/2020';
-import { LiteralTypeNode, StringLiteral, UnionTypeNode } from 'typescript';
+import { Generator } from '../../Generator.ts';
+import type Ajv from 'ajv/dist/2020.js';
+import type { LiteralTypeNode, StringLiteral, UnionTypeNode } from 'typescript';
 type RawData = {
     type: 'string';
     enum: [string, ...string[]];

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

@@ -1,5 +1,5 @@
-import { Generator, } from '../../Generator';
-import { create_typed_union, } from '../../../TsFactoryWrapper';
+import { Generator, } from "../../Generator.js";
+import { create_typed_union, } from "../../../TsFactoryWrapper.js";
 export const schema = {
     type: 'object',
     required: ['type', 'enum'],

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Pattern.d.ts

@@ -1,6 +1,6 @@
-import Ajv from 'ajv/dist/2020';
-import { TypeReferenceNode } from 'typescript';
-import { Generator } from '../../Generator';
+import type Ajv from 'ajv/dist/2020.js';
+import type { TypeReferenceNode } from 'typescript';
+import { Generator } from '../../Generator.ts';
 export declare class Pattern extends Generator<{
     type: 'string';
     pattern: string;

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

@@ -1,5 +1,5 @@
-import { create_literal, type_reference_node, } from '../../../TsFactoryWrapper';
-import { Generator, } from '../../Generator';
+import { create_literal, type_reference_node, } from "../../../TsFactoryWrapper.js";
+import { Generator, } from "../../Generator.js";
 export class Pattern extends Generator {
     constructor(ajv) {
         super(ajv, {