@satisfactory-dev/docs.json.ts 0.6.1

package/lib/TypesDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -0,0 +1,18 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { local_ref, } from '../../StringStartsWith';
+import { is_UnrealEngineString_parent, } from '../../CustomParsingTypes/UnrealEngineString';
+export class UnrealEngineString extends CandidatesDiscovery {
+    discovery_candidates(current, discovered_types) {
+        if (object_has_property(current, '$defs', value_is_non_array_object)) {
+            for (const entry of Object.entries(current.$defs)) {
+                const [property, value] = entry;
+                if (is_UnrealEngineString_parent(value)) {
+                    discovered_types.add(local_ref(property));
+                }
+            }
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=UnrealEngineString.js.map

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

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

package/lib/TypesDiscovery/CustomParsingTypes/typed_string.js

@@ -0,0 +1,34 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { is_string, local_ref, } from '../../StringStartsWith';
+export class typed_string extends CandidatesDiscovery {
+    discovery_candidates(current, discovered_types) {
+        if (object_has_property(current, '$defs', value_is_non_array_object)) {
+            for (const entry of Object.entries(current.$defs)) {
+                const [property, value] = entry;
+                if (this.is_typed_string(value)) {
+                    discovered_types.add(local_ref(property));
+                }
+            }
+        }
+        return undefined;
+    }
+    is_typed_string(maybe) {
+        return (value_is_non_array_object(maybe)
+            && 3 === Object.keys(maybe).length
+            && object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_property_that_equals(maybe, 'minLength', 1)
+            && object_has_property(maybe, 'typed_string', value_is_non_array_object)
+            && ((2 === Object.keys(maybe.typed_string).length
+                && object_has_non_empty_array_property(maybe.typed_string, 'required', is_string)
+                && object_has_property(maybe.typed_string, 'properties', value_is_non_array_object))
+                || (((4 === Object.keys(maybe.typed_string).length
+                    && object_has_property(maybe.typed_string, 'maxItems', (e) => 'number' === typeof e))
+                    || (3 === Object.keys(maybe.typed_string).length
+                        && !object_has_property(maybe.typed_string, 'maxItems')))
+                    && object_has_property(maybe.typed_string, 'minItems', (e) => 'number' === typeof e)
+                    && object_has_property_that_equals(maybe.typed_string, 'items', false)
+                    && object_has_non_empty_array_property(maybe.typed_string, 'prefixItems', value_is_non_array_object))));
+    }
+}
+//# sourceMappingURL=typed_string.js.map

package/lib/TypesDiscovery/JsonSchema/$ref.d.ts

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

package/lib/TypesDiscovery/JsonSchema/$ref.js

@@ -0,0 +1,33 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { is_string, } from '../../StringStartsWith';
+export class $ref extends CandidatesDiscovery {
+    $defs;
+    constructor(schema) {
+        super(schema);
+        this.$defs =
+            object_has_property(schema, '$defs', value_is_non_array_object)
+                ? Object.fromEntries(Object.keys(schema.$defs).map(e => [e, true]))
+                : {};
+    }
+    discovery_candidates(current, discovered_types) {
+        const $defs = this.$defs;
+        function has_definition_$ref(maybe) {
+            return (object_has_property(maybe, '$ref', is_string)
+                && maybe.$ref.startsWith('#/$defs/')
+                && maybe.$ref.substring(8) in $defs);
+        }
+        function schema_has_definition(maybe, schema) {
+            return (maybe.startsWith('#/$defs/')
+                && maybe.substring(8) in schema.$defs);
+        }
+        if (has_definition_$ref(current)
+            && schema_has_definition(current.$ref, this.schema)
+            && !discovered_types.has(current.$ref)) {
+            discovered_types.add(current.$ref);
+            return [this.schema.$defs[current.$ref.substring(8)]];
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=$ref.js.map

package/lib/TypesDiscovery/JsonSchema/const.d.ts

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

package/lib/TypesDiscovery/JsonSchema/const.js

@@ -0,0 +1,22 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { is_string, local_ref, } from '../../StringStartsWith';
+export class ConstString extends CandidatesDiscovery {
+    discovery_candidates(current, discovered_types) {
+        if (object_has_property(current, '$defs', value_is_non_array_object)) {
+            for (const entry of Object.entries(current.$defs)) {
+                const [property, value] = entry;
+                if (this.is_const_string(value)) {
+                    discovered_types.add(local_ref(property));
+                }
+            }
+        }
+        return undefined;
+    }
+    is_const_string(maybe) {
+        return (object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_property(maybe, 'const', is_string)
+            && 2 === Object.keys(maybe).length);
+    }
+}
+//# sourceMappingURL=const.js.map

package/lib/TypesDiscovery/JsonSchema/enum.d.ts

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

package/lib/TypesDiscovery/JsonSchema/enum.js

@@ -0,0 +1,22 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { is_string, local_ref, } from '../../StringStartsWith';
+export class EnumString extends CandidatesDiscovery {
+    discovery_candidates(current, discovered_types) {
+        if (object_has_property(current, '$defs', value_is_non_array_object)) {
+            for (const entry of Object.entries(current.$defs)) {
+                const [property, value] = entry;
+                if (this.is_enum_string(value)) {
+                    discovered_types.add(local_ref(property));
+                }
+            }
+        }
+        return undefined;
+    }
+    is_enum_string(maybe) {
+        return (object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_non_empty_array_property(maybe, 'enum', is_string)
+            && 2 === Object.keys(maybe).length);
+    }
+}
+//# sourceMappingURL=enum.js.map

package/lib/TypesDiscovery/JsonSchema/properties.d.ts

@@ -0,0 +1,4 @@
+import { CandidatesDiscovery } from '../CandidatesDiscovery';
+export declare class properties extends CandidatesDiscovery {
+    discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
+}

package/lib/TypesDiscovery/JsonSchema/properties.js

@@ -0,0 +1,14 @@
+import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { is_non_empty_array, object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+export class properties extends CandidatesDiscovery {
+    discovery_candidates(current) {
+        if (object_has_property(current, 'properties', value_is_non_array_object)) {
+            const properties = Object.values(current.properties);
+            if (is_non_empty_array(properties)) {
+                return properties;
+            }
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=properties.js.map

package/lib/TypesDiscovery/non_array_object_property.d.ts

@@ -0,0 +1,4 @@
+import { PropertyDependentDiscovery } from './CandidatesDiscovery';
+export declare class non_array_object_property extends PropertyDependentDiscovery {
+    discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
+}

package/lib/TypesDiscovery/non_array_object_property.js

@@ -0,0 +1,11 @@
+import { PropertyDependentDiscovery, } from './CandidatesDiscovery';
+import { object_has_property, value_is_non_array_object, } from '../CustomParsingTypes/CustomPairingTypes';
+export class non_array_object_property extends PropertyDependentDiscovery {
+    discovery_candidates(current) {
+        if (object_has_property(current, this.property, value_is_non_array_object)) {
+            return [current[this.property]];
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=non_array_object_property.js.map

package/lib/TypesDiscovery/non_empty_array_property.d.ts

@@ -0,0 +1,4 @@
+import { PropertyDependentDiscovery } from './CandidatesDiscovery';
+export declare class non_empty_array_property extends PropertyDependentDiscovery {
+    discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
+}

package/lib/TypesDiscovery/non_empty_array_property.js

@@ -0,0 +1,11 @@
+import { PropertyDependentDiscovery, } from './CandidatesDiscovery';
+import { object_has_non_empty_array_property, value_is_non_array_object, } from '../CustomParsingTypes/CustomPairingTypes';
+export class non_empty_array_property extends PropertyDependentDiscovery {
+    discovery_candidates(current) {
+        if (object_has_non_empty_array_property(current, this.property, value_is_non_array_object)) {
+            return current[this.property];
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=non_empty_array_property.js.map

package/lib/TypesDiscovery.d.ts

@@ -0,0 +1,24 @@
+import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
+import { DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
+import { local_ref } from './StringStartsWith';
+export declare class TypesDiscovery {
+    private discovery;
+    private readonly candidates_discovery;
+    private readonly docs;
+    constructor(candidates_discovery: [CandidatesDiscovery, ...CandidatesDiscovery[]], docs: DocsTsGenerator);
+    discover_types(): Promise<{
+        discovered_types: local_ref<string>[];
+        missed_types: string[];
+    }>;
+    private discover_types_from;
+    static custom_parsing_types(schema: SchemaObject): ([
+        CandidatesDiscovery,
+        ...CandidatesDiscovery[]
+    ]);
+    static generate_is_NativeClass(docs: DocsTsGenerator): Promise<import("ajv/dist/types").ValidateFunction<DocsDataItem>>;
+    static standard_jsonschema_discovery(schema: SchemaObject): ([
+        CandidatesDiscovery,
+        ...CandidatesDiscovery[]
+    ]);
+}

package/lib/TypesDiscovery.js

@@ -0,0 +1,77 @@
+import { object_has_property, value_is_non_array_object, } from './CustomParsingTypes/CustomPairingTypes';
+import { properties, } from './TypesDiscovery/JsonSchema/properties';
+import { non_empty_array_property, } from './TypesDiscovery/non_empty_array_property';
+import { $ref, } from './TypesDiscovery/JsonSchema/$ref';
+import { non_array_object_property, } from './TypesDiscovery/non_array_object_property';
+import { compile, } from './AjvUtilities';
+import { local_ref, } from './StringStartsWith';
+import { typed_string, } from './TypesDiscovery/CustomParsingTypes/typed_string';
+import { ConstString, } from './TypesDiscovery/JsonSchema/const';
+import { EnumString, } from './TypesDiscovery/JsonSchema/enum';
+import { UnrealEngineString, } from './TypesDiscovery/CustomParsingTypes/UnrealEngineString';
+export class TypesDiscovery {
+    discovery;
+    candidates_discovery;
+    docs;
+    constructor(candidates_discovery, docs) {
+        this.candidates_discovery = candidates_discovery;
+        this.docs = docs;
+    }
+    async discover_types() {
+        if (!this.discovery) {
+            const schema = await this.docs.schema();
+            const discovered_types = new Set();
+            this.discover_types_from(schema, schema, discovered_types);
+            this.discovery = Promise.resolve({
+                discovered_types: [...discovered_types.values()],
+                missed_types: Object.keys(object_has_property(schema, '$defs', value_is_non_array_object)
+                    ? schema.$defs
+                    : {}).map(local_ref).filter(maybe => !discovered_types.has(maybe)),
+            });
+        }
+        return this.discovery;
+    }
+    discover_types_from(current, schema, discovered_types) {
+        if (!value_is_non_array_object(current)) {
+            return;
+        }
+        for (const discovery of this.candidates_discovery) {
+            const candidates = discovery.discovery_candidates(current, discovered_types);
+            for (const candidate of (candidates || [])) {
+                this.discover_types_from(candidate, schema, discovered_types);
+            }
+        }
+    }
+    static custom_parsing_types(schema) {
+        return [
+            new UnrealEngineString(schema),
+            new typed_string(schema),
+        ];
+    }
+    static async generate_is_NativeClass(docs) {
+        const schema = await docs.schema();
+        if (!object_has_property(schema, '$defs', value_is_non_array_object)) {
+            throw new Error('Schema appears to have no $defs');
+        }
+        if (!object_has_property(schema.$defs, 'NativeClass', value_is_non_array_object)) {
+            throw new Error('Could not find NativeClass on provided schema!');
+        }
+        return compile(docs.ajv, {
+            $defs: schema.$defs,
+            ...schema.$defs.NativeClass,
+        });
+    }
+    static standard_jsonschema_discovery(schema) {
+        return [
+            new non_empty_array_property('prefixItems', schema),
+            new non_empty_array_property('oneOf', schema),
+            new non_empty_array_property('anyOf', schema),
+            new non_array_object_property('items', schema),
+            new properties(schema),
+            new $ref(schema),
+            new ConstString(schema),
+            new EnumString(schema),
+        ];
+    }
+}
+//# sourceMappingURL=TypesDiscovery.js.map

package/lib/TypesGeneration/validators.d.ts

@@ -0,0 +1,9 @@
+import ts from 'typescript';
+export declare const string_starts_with: {
+    file: string;
+    node: ts.TypeAliasDeclaration;
+};
+export declare const StringPassedRegExp: {
+    file: string;
+    node: ts.TypeAliasDeclaration;
+};

package/lib/TypesGeneration/validators.js

@@ -0,0 +1,26 @@
+import ts from 'typescript';
+import { create_modifiers, create_type, createParameter, type_reference_node, } from '../TsFactoryWrapper';
+export const string_starts_with = {
+    file: 'utils/validators.ts',
+    node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), ts.factory.createIdentifier('StringStartsWith'), [
+        ts.factory.createTypeParameterDeclaration(undefined, 'prefix', create_type('string')),
+    ], ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createMappedTypeNode(undefined, ts.factory.createTypeParameterDeclaration(undefined, 'pseudo_key', ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createTypeLiteralNode([
+        ts.factory.createIndexSignature(undefined, [
+            createParameter('key', create_type('string')),
+        ], create_type('unknown')),
+    ]))), ts.factory.createConditionalTypeNode(type_reference_node('pseudo_key'), create_type('string'), ts.factory.createTemplateLiteralType(ts.factory.createTemplateHead(''), [
+        ts.factory.createTemplateLiteralTypeSpan(type_reference_node('prefix'), ts.factory.createTemplateMiddle('')),
+        ts.factory.createTemplateLiteralTypeSpan(type_reference_node('pseudo_key'), ts.factory.createTemplateTail('')),
+    ]), create_type('never')), undefined, create_type('string'), undefined))),
+};
+export const StringPassedRegExp = {
+    file: 'utils/validators.ts',
+    node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), 'StringPassedRegExp', [
+        ts.factory.createTypeParameterDeclaration(undefined, 'pattern', create_type('string')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'T', create_type('string'), create_type('string')),
+    ], ts.factory.createIntersectionTypeNode([
+        type_reference_node('T'),
+        ts.factory.createMappedTypeNode(undefined, ts.factory.createTypeParameterDeclaration(undefined, 'pseudo_key', type_reference_node('pattern')), undefined, undefined, create_type('never'), undefined),
+    ])),
+};
+//# sourceMappingURL=validators.js.map

package/lib/TypesGeneration.d.ts

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+export declare type import_these_somewhere_later = {
+    [key: string]: string[];
+};
+export declare type import_these_later = {
+    [key: string]: import_these_somewhere_later;
+};
+export declare type imports_shorthand = {
+    import_these: [string, ...string[]];
+    from: string;
+}[];
+export declare class ImportTracker {
+    private imports;
+    get number_of_files(): number;
+    generate_imports(file: string): ts.ImportDeclaration[];
+    merge_and_set_imports(imports: import_these_later): void;
+}

package/lib/TypesGeneration.js

@@ -0,0 +1,53 @@
+import ts from 'typescript';
+import { NoMatchError, } from './Exceptions';
+export class ImportTracker {
+    imports = {};
+    get number_of_files() {
+        return Object.keys(this.imports).length;
+    }
+    generate_imports(file) {
+        if (!(file in this.imports)) {
+            return [];
+        }
+        return this.imports[file].map((entry) => {
+            return ts.factory.createImportDeclaration([], ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(entry.import_these.map((import_this) => {
+                return ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(import_this));
+            }))), ts.factory.createStringLiteral(entry.from));
+        });
+    }
+    merge_and_set_imports(imports) {
+        for (const entry of Object.entries(imports)) {
+            const [filename, file_imports] = entry;
+            const merge_here = Object.fromEntries((this.imports[filename] || []).map((shorthand_entry) => {
+                return [
+                    shorthand_entry.from,
+                    shorthand_entry.import_these,
+                ];
+            }));
+            for (const inner_entry of Object.entries(file_imports)) {
+                const [from, import_these] = inner_entry;
+                if (from.endsWith('.ts')) {
+                    throw new NoMatchError(from, 'files ending with .ts should not end up here');
+                }
+                if (import_these.length) {
+                    if (!(from in merge_here)) {
+                        merge_here[from] = import_these;
+                    }
+                    else {
+                        for (const import_this of import_these) {
+                            if (!merge_here[from].includes(import_this)) {
+                                merge_here[from].push(import_this);
+                            }
+                        }
+                    }
+                }
+            }
+            if (Object.keys(merge_here).length) {
+                this.imports[filename] = Object.entries(merge_here).map((unpack) => {
+                    return { from: unpack[0], import_these: unpack[1] };
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=TypesGeneration.js.map

package/lib/__dirname.d.ts

@@ -0,0 +1 @@
+export declare function __dirname_from_meta(meta: ImportMeta): string;

package/lib/__dirname.js

@@ -0,0 +1,6 @@
+import { dirname, } from "node:path";
+import { fileURLToPath, } from "node:url";
+export function __dirname_from_meta(meta) {
+    return fileURLToPath(dirname(meta.url));
+}
+//# sourceMappingURL=__dirname.js.map

package/lib/helpers.d.ts

@@ -0,0 +1,5 @@
+import { DocsTsGenerator } from './DocsTsGenerator';
+export declare const docs: DocsTsGenerator;
+export declare const skip_because_docs_dot_json_not_yet_bundled: {
+    skip: string | boolean;
+};

package/lib/helpers.js

@@ -0,0 +1,29 @@
+import { existsSync, } from 'node:fs';
+import { DocsTsGenerator, } from './DocsTsGenerator';
+import { __dirname_from_meta, } from './__dirname';
+import Ajv from 'ajv/dist/2020';
+import { configure_ajv, } from './DocsValidation';
+const __dirname = __dirname_from_meta(import.meta);
+const ajv = new Ajv({
+    verbose: true,
+    logger: false,
+    allErrors: false,
+    code: {
+        source: true,
+        esm: true,
+        lines: true,
+        optimize: 2,
+    },
+});
+configure_ajv(ajv);
+export const docs = new DocsTsGenerator({
+    ajv,
+    docs_path: `${__dirname}/../data/Docs.json`,
+    cache_path: `${__dirname}/../data/`,
+});
+export const skip_because_docs_dot_json_not_yet_bundled = {
+    skip: existsSync(`${__dirname}/../data/Docs.json`)
+        ? false
+        : 'Docs.json not yet bundled!',
+};
+//# sourceMappingURL=helpers.js.map

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AjvUtilities';
+export * from './ArrayUtilities';
+export * from './DocsTsGenerator';
+export * from './DocsValidation';
+export * from './Exceptions';
+export * from './StringStartsWith';
+export * from './TypeDefinitionWriter';
+export * from '../setup_PerformanceObserver';

package/lib/index.js

@@ -0,0 +1,9 @@
+export * from './AjvUtilities';
+export * from './ArrayUtilities';
+export * from './DocsTsGenerator';
+export * from './DocsValidation';
+export * from './Exceptions';
+export * from './StringStartsWith';
+export * from './TypeDefinitionWriter';
+export * from '../setup_PerformanceObserver';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "type": "module",
+  "name": "@satisfactory-dev/docs.json.ts",
+  "description": "TypeScript mappings for the Docs.json file that ships with Satisfactory",
+  "license": "Apache-2.0",
+  "keywords": [
+    "satisfactory",
+    "Docs.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/satisfactory-dev/Docs.json.ts.git"
+  },
+  "funding": "https://github.com/satisfactory-dev/Docs.json.ts?sponsor=1",
+  "exports": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "test": "ts-node ./tests.ts",
+    "generate": "ts-node ./generate-typescript-types.ts",
+    "validate": "ts-node validate-Docs.ts"
+  },
+  "devDependencies": {
+    "@satisfactory-dev/custom-assert": "^0.2.2",
+    "@signpostmarv/ts-assert": "^0.3.0",
+    "@types/eslint": "^8.56.6",
+    "@types/node": "^20.11.20",
+    "c8": "^10.1.2",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "eslint": "^8.57.0",
+    "glob": "^10.3.10",
+    "prettier": "^3.2.5",
+    "typescript": "~5.5.2",
+    "typescript-eslint": "^7.3.1"
+  },
+  "version": "0.6.1"
+}