@satisfactory-dev/docs.json.ts 0.16.1 → 0.17.1

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, {

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

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

package/lib/TypeDefinitionDiscovery/JsonSchema/String.js

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

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

@@ -1,6 +1,6 @@
-import { IntersectionTypeNode } from 'typescript';
-import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
-import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+import type { IntersectionTypeNode } from 'typescript';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery.ts';
+import type { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery.ts';
 type RawData = {
     allOf: [
         {

package/lib/TypeDefinitionDiscovery/JsonSchema/allOf.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { GeneratorDoesDiscovery, } from "../GeneratorDoesDiscovery.js";
 export const schema = {
     type: 'object',
     required: ['allOf'],

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

@@ -1,6 +1,6 @@
-import { UnionTypeNode } from 'typescript';
-import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
-import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+import type { UnionTypeNode } from 'typescript';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery.ts';
+import type { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery.ts';
 type RawData = {
     oneOf: [
         {

package/lib/TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { GeneratorDoesDiscovery, } from "../GeneratorDoesDiscovery.js";
 export const schema = {
     oneOf: [
         {

package/lib/TypeDefinitionDiscovery.d.ts

@@ -1,11 +1,13 @@
-import Ajv from 'ajv/dist/2020';
-import { TypesDiscovery } from './TypesDiscovery';
-import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
-import ts, { TypeNode } from 'typescript';
-import { AnyGenerator } from './TypeDefinitionDiscovery/Generator';
-import { FilesGenerator } from './FilesGenerator';
-import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
-import { GeneratesMarkdown } from './MarkdownUtilities';
+import type Ajv from 'ajv/dist/2020.js';
+import { TypesDiscovery } from './TypesDiscovery.ts';
+import type { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery.ts';
+import type { TypeNode } from 'typescript';
+import ts from 'typescript';
+import type { AnyGenerator } from './TypeDefinitionDiscovery/Generator.ts';
+import { FilesGenerator } from './FilesGenerator.ts';
+import type { docs_versions } from './DocsTsGenerator.ts';
+import type { DocsTsGenerator } from './DocsTsGenerator.ts';
+import type { GeneratesMarkdown } from './MarkdownUtilities.ts';
 export type ref_discovery_type = {
     found_types: {
         [key: string]: (raw_data: unknown) => TypeNode;