@valkyrjaio/sindri 26.4.0 → 26.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyrjaio/sindri",
-    "version": "26.4.0",
+    "version": "26.5.0",
     "description": "The Valkyrja Sindri build tool.",
     "homepage": "https://www.valkyrja.io/sindri",
     "keywords": [
@@ -38,7 +38,7 @@
         "node": ">=22"
     },
     "dependencies": {
-        "@valkyrjaio/valkyrja": "^26.4.0",
+        "@valkyrjaio/valkyrja": "^26.4.1",
         "ts-morph": "^28.0.0"
     },
     "scripts": {

package/src/Sindri/Ast/ConfigSourceReader.ts

@@ -0,0 +1,356 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Node } from 'ts-morph';
+
+import { AstReader } from './Abstract/AstReader.ts';
+import { ConfigImport } from './Data/ConfigImport.ts';
+import { ConfigSourceResult } from './Data/Result/ConfigSourceResult.ts';
+
+import type { ClassDeclaration, SourceFile } from 'ts-morph';
+
+import type { ConfigSourceReaderContract } from './Contract/ConfigSourceReaderContract.ts';
+
+/**
+ * Reads an application config class and returns every field as source text.
+ *
+ * Two shapes are supported, because an application config may either extend a
+ * framework config and pass positional `super()` arguments, or implement the
+ * contract directly and declare its own properties:
+ *
+ * ```ts
+ * class Config extends HttpConfig { constructor() { super('App', process.cwd(), ...); } }
+ * class Config implements HttpConfigContract { readonly namespace = 'App'; }
+ * ```
+ *
+ * Values are never evaluated. `process.env['APP_KEY']` is carried through as the
+ * text `process.env['APP_KEY']`, so a generated config keeps whatever the author
+ * wrote — including expressions no static reader could resolve.
+ */
+export class ConfigSourceReader extends AstReader implements ConfigSourceReaderContract {
+    /**
+     * The constructor parameter order of each framework config base.
+     *
+     * Positional `super()` arguments carry no names, so the base class a config
+     * extends is what gives each argument its meaning. `CliConfig` inserts two
+     * fields ahead of `providers`, so the orders are not interchangeable.
+     */
+    protected static readonly BASE_FIELDS: Readonly<Record<string, readonly string[]>> = {
+        Config: [
+            'namespace',
+            'dir',
+            'version',
+            'environment',
+            'debugMode',
+            'timezone',
+            'key',
+            'dataPath',
+            'dataNamespace',
+            'providers',
+            'callbacks',
+        ],
+        HttpConfig: [
+            'namespace',
+            'dir',
+            'version',
+            'environment',
+            'debugMode',
+            'timezone',
+            'key',
+            'dataPath',
+            'dataNamespace',
+            'providers',
+            'callbacks',
+            'requestReceivedMiddleware',
+            'routeMatchedMiddleware',
+            'routeNotMatchedMiddleware',
+            'routeDispatchedMiddleware',
+            'throwableCaughtMiddleware',
+            'sendingResponseMiddleware',
+            'responseSentMiddleware',
+        ],
+        CliConfig: [
+            'namespace',
+            'dir',
+            'version',
+            'environment',
+            'debugMode',
+            'timezone',
+            'key',
+            'dataPath',
+            'dataNamespace',
+            'applicationName',
+            'defaultCommandName',
+            'providers',
+            'callbacks',
+            'inputReceivedMiddleware',
+            'routeMatchedMiddleware',
+            'routeNotMatchedMiddleware',
+            'routeDispatchedMiddleware',
+            'throwableCaughtMiddleware',
+            'processExitingMiddleware',
+        ],
+    };
+
+    /** The contract each framework config base satisfies. */
+    protected static readonly BASE_CONTRACTS: Readonly<Record<string, string>> = {
+        Config: 'ConfigContract',
+        HttpConfig: 'HttpConfigContract',
+        CliConfig: 'CliConfigContract',
+    };
+
+    /** Where each contract is imported from. */
+    protected static readonly CONTRACT_SPECIFIERS: Readonly<Record<string, string>> = {
+        ConfigContract: '@valkyrjaio/valkyrja/Application/Data/Contract/ConfigContract.ts',
+        HttpConfigContract: '@valkyrjaio/valkyrja/Application/Data/Contract/HttpConfigContract.ts',
+        CliConfigContract: '@valkyrjaio/valkyrja/Application/Data/Contract/CliConfigContract.ts',
+    };
+
+    readFile(filePath: string): ConfigSourceResult {
+        const context = this.parseClassFile(filePath);
+
+        if (context === undefined) {
+            return new ConfigSourceResult();
+        }
+
+        const { sourceFile, classDecl } = context;
+        const className = classDecl.getName() ?? '';
+
+        if (className === '') {
+            return new ConfigSourceResult();
+        }
+
+        const contract = this.resolveContract(classDecl);
+
+        if (contract === undefined) {
+            return new ConfigSourceResult();
+        }
+
+        const base = this.readBase(classDecl, context.useMap, filePath);
+        const fields = { ...base.fields, ...this.readFields(classDecl) };
+        const types = { ...base.types, ...this.readPropertyTypes(classDecl) };
+
+        if (Object.keys(fields).length === 0) {
+            return new ConfigSourceResult();
+        }
+
+        return new ConfigSourceResult(className, contract.name, contract.specifier, fields, types, [
+            ...this.readImports(sourceFile),
+            ...base.imports,
+        ]);
+    }
+
+    /**
+     * Read the defaults of the framework config a class extends.
+     *
+     * A config passes only the arguments it wants to change, so the rest come
+     * from the base's constructor parameter defaults. A generated config
+     * implements the contract directly and inherits nothing, so those defaults
+     * must be copied in or they are silently lost — `CliConfig`, for one,
+     * defaults several middleware lists to non-empty values.
+     */
+    protected readBase(
+        classDecl: ClassDeclaration,
+        useMap: Record<string, string>,
+        filePath: string,
+    ): { fields: Record<string, string>; types: Record<string, string>; imports: ConfigImport[] } {
+        const baseName = classDecl.getExtends()?.getExpression().getText() ?? '';
+
+        if (ConfigSourceReader.BASE_FIELDS[baseName] === undefined) {
+            return { fields: {}, types: {}, imports: [] };
+        }
+
+        const baseFile = this.parseDeclaringSourceFile(baseName, useMap, filePath);
+        const baseClass = baseFile?.getClass(baseName);
+
+        if (baseFile === undefined || baseClass === undefined) {
+            return { fields: {}, types: {}, imports: [] };
+        }
+
+        const fields: Record<string, string> = {};
+        const types: Record<string, string> = {};
+
+        for (const parameter of baseClass.getConstructors()[0]?.getParameters() ?? []) {
+            const initializer = parameter.getInitializer();
+
+            if (initializer === undefined) {
+                continue;
+            }
+
+            fields[parameter.getName()] = initializer.getText();
+
+            const typeNode = parameter.getTypeNode();
+
+            if (typeNode !== undefined) {
+                types[parameter.getName()] = typeNode.getText();
+            }
+        }
+
+        return { fields, types, imports: this.readImports(baseFile) };
+    }
+
+    /**
+     * Determine which config contract the class satisfies, and where that
+     * contract is imported from.
+     *
+     * A class that extends a framework config takes that base's contract; a
+     * standalone class names its contract in the `implements` clause. Returns
+     * undefined when neither names a contract this reader knows.
+     */
+    protected resolveContract(classDecl: ClassDeclaration): { name: string; specifier: string } | undefined {
+        const baseName = classDecl.getExtends()?.getExpression().getText() ?? '';
+        const names = [ConfigSourceReader.BASE_CONTRACTS[baseName]];
+
+        for (const implemented of classDecl.getImplements()) {
+            names.push(implemented.getExpression().getText());
+        }
+
+        for (const name of names) {
+            const specifier = name === undefined ? undefined : ConfigSourceReader.CONTRACT_SPECIFIERS[name];
+
+            if (name !== undefined && specifier !== undefined) {
+                return { name, specifier };
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Read every field initializer as source text, from whichever shape the
+     * class uses.
+     */
+    protected readFields(classDecl: ClassDeclaration): Record<string, string> {
+        const baseName = classDecl.getExtends()?.getExpression().getText() ?? '';
+        const order = ConfigSourceReader.BASE_FIELDS[baseName];
+
+        if (order !== undefined) {
+            return this.readFieldsFromSuperCall(classDecl, order);
+        }
+
+        return this.readFieldsFromProperties(classDecl);
+    }
+
+    /**
+     * Map positional `super()` arguments onto the base's field order.
+     *
+     * Arguments the author omitted keep the base class default, so they are left
+     * out of the result rather than recorded as empty.
+     */
+    protected readFieldsFromSuperCall(classDecl: ClassDeclaration, order: readonly string[]): Record<string, string> {
+        const fields: Record<string, string> = {};
+        const args = this.findSuperCallArguments(classDecl);
+
+        for (const [index, arg] of args.entries()) {
+            const name = order[index];
+
+            if (name === undefined) {
+                continue;
+            }
+
+            fields[name] = arg;
+        }
+
+        return fields;
+    }
+
+    /**
+     * Collect the argument source texts of the constructor's `super()` call.
+     */
+    protected findSuperCallArguments(classDecl: ClassDeclaration): string[] {
+        const constructor = classDecl.getConstructors()[0];
+
+        if (constructor === undefined) {
+            return [];
+        }
+
+        for (const statement of constructor.getStatements()) {
+            if (!Node.isExpressionStatement(statement)) {
+                continue;
+            }
+
+            const expression = statement.getExpression();
+
+            if (!Node.isCallExpression(expression) || expression.getExpression().getKindName() !== 'SuperKeyword') {
+                continue;
+            }
+
+            return expression.getArguments().map((arg) => arg.getText());
+        }
+
+        return [];
+    }
+
+    /**
+     * Read initializers from a standalone class's property declarations.
+     */
+    protected readFieldsFromProperties(classDecl: ClassDeclaration): Record<string, string> {
+        const fields: Record<string, string> = {};
+
+        for (const property of classDecl.getProperties()) {
+            if (property.isStatic()) {
+                continue;
+            }
+
+            const initializer = property.getInitializer();
+
+            if (initializer === undefined) {
+                continue;
+            }
+
+            fields[property.getName()] = initializer.getText();
+        }
+
+        return fields;
+    }
+
+    /**
+     * Read the declared types of a standalone class's own properties.
+     */
+    protected readPropertyTypes(classDecl: ClassDeclaration): Record<string, string> {
+        const types: Record<string, string> = {};
+
+        for (const property of classDecl.getProperties()) {
+            const typeNode = property.getTypeNode();
+
+            if (!property.isStatic() && typeNode !== undefined) {
+                types[property.getName()] = typeNode.getText();
+            }
+        }
+
+        return types;
+    }
+
+    /**
+     * Collect every named import in the config source file.
+     *
+     * Default and namespace imports are skipped: a config field can only
+     * reference a named binding, so nothing else can appear in the copied text.
+     */
+    protected readImports(sourceFile: SourceFile): ConfigImport[] {
+        const imports: ConfigImport[] = [];
+        const ownerPath = sourceFile.getFilePath();
+
+        for (const declaration of sourceFile.getImportDeclarations()) {
+            const specifier = declaration.getModuleSpecifierValue();
+            const isTypeOnly = declaration.isTypeOnly();
+            const resolvedPath = specifier.startsWith('.')
+                ? this.resolveModuleSpecifierToFilePath(specifier, ownerPath)
+                : '';
+
+            for (const named of declaration.getNamedImports()) {
+                imports.push(
+                    new ConfigImport(named.getName(), specifier, isTypeOnly || named.isTypeOnly(), resolvedPath),
+                );
+            }
+        }
+
+        return imports;
+    }
+}

package/src/Sindri/Ast/Contract/ConfigSourceReaderContract.ts

@@ -0,0 +1,14 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ConfigSourceResult } from '../Data/Result/ConfigSourceResult.ts';
+
+export interface ConfigSourceReaderContract {
+    readFile(filePath: string): ConfigSourceResult;
+}

package/src/Sindri/Ast/Data/ConfigImport.ts

@@ -0,0 +1,26 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * A single named import read from a config source file.
+ *
+ * A relative specifier is only meaningful next to the file that declares it.
+ * Imports copied out of a framework config base therefore carry `resolvedPath`,
+ * the absolute path the specifier points at, so the generate layer can rewrite
+ * the specifier for wherever the generated file goes. An import that already
+ * uses a bare package specifier needs no rewrite and leaves `resolvedPath` empty.
+ */
+export class ConfigImport {
+    constructor(
+        readonly name: string,
+        readonly specifier: string,
+        readonly isType: boolean = false,
+        readonly resolvedPath: string = '',
+    ) {}
+}

package/src/Sindri/Ast/Data/Result/ConfigSourceResult.ts

@@ -0,0 +1,28 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ConfigImport } from '../ConfigImport.ts';
+
+/**
+ * The source-level shape of an application config class.
+ *
+ * Field initializers are kept as source text rather than evaluated values, so a
+ * generated config reproduces expressions such as `process.env['APP_KEY']` or
+ * `process.cwd()` exactly as the author wrote them.
+ */
+export class ConfigSourceResult {
+    constructor(
+        readonly className: string = '',
+        readonly contractName: string = '',
+        readonly contractSpecifier: string = '',
+        readonly fields: Readonly<Record<string, string>> = {},
+        readonly types: Readonly<Record<string, string>> = {},
+        readonly imports: readonly ConfigImport[] = [],
+    ) {}
+}

package/src/Sindri/Cli/Command/GenerateCachedConfigCommand.ts

@@ -0,0 +1,47 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ConfigReader } from '../../Ast/ConfigReader.ts';
+import { ConfigSourceReader } from '../../Ast/ConfigSourceReader.ts';
+import { GenerateCachedConfigFromAst } from '../../Generate/Abstract/GenerateCachedConfigFromAst.ts';
+import { AstCachedConfigFileGenerator } from '../../Generator/Ast/Config/AstCachedConfigFileGenerator.ts';
+
+import type { ConfigReaderContract } from '../../Ast/Contract/ConfigReaderContract.ts';
+import type { ConfigSourceReaderContract } from '../../Ast/Contract/ConfigSourceReaderContract.ts';
+import type { CachedConfigFileGeneratorContract } from '../../Generator/Config/Contract/CachedConfigFileGeneratorContract.ts';
+import type { OutputContract } from '@valkyrjaio/valkyrja/Cli/Interaction/Output/Contract/OutputContract.ts';
+import type { OutputFactoryContract } from '@valkyrjaio/valkyrja/Cli/Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
+import type { RouteContract } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts';
+
+export class GenerateCachedConfigCommand extends GenerateCachedConfigFromAst {
+    public constructor(
+        protected override readonly route: RouteContract,
+        outputFactory: OutputFactoryContract,
+        configReader: ConfigReaderContract = new ConfigReader(),
+        configSourceReader: ConfigSourceReaderContract = new ConfigSourceReader(),
+        cachedConfigGenerator: CachedConfigFileGeneratorContract = new AstCachedConfigFileGenerator(),
+    ) {
+        super(
+            outputFactory,
+            route,
+            'Generating Cached Config From Config',
+            configReader,
+            configSourceReader,
+            cachedConfigGenerator,
+        );
+    }
+
+    public run(): OutputContract {
+        return this.generateCachedConfig();
+    }
+
+    protected override getConfigFilePath(): string {
+        return this.route.getArgument('config').getArguments()[0]?.getValue() ?? '';
+    }
+}

package/src/Sindri/Constant/CommandName.ts

@@ -9,4 +9,5 @@
 
 export class CommandName {
     static readonly DATA_GENERATE = 'data:generate' as const;
+    static readonly CONFIG_GENERATE = 'config:generate' as const;
 }

package/src/Sindri/Constant/SindriInfo.ts

@@ -8,8 +8,8 @@
  */
 
 export class SindriInfo {
-    static readonly VERSION = '26.4.0' as const;
-    static readonly VERSION_BUILD_DATE_TIME = 'July 27 2026 22:16:03 MST' as const;
+    static readonly VERSION = '26.5.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'July 31 2026 08:59:24 MST' as const;
     static readonly ICON = `\
     ██████████
     ████  ████

package/src/Sindri/Generate/Abstract/GenerateCachedConfigFromAst.ts

@@ -0,0 +1,159 @@
+/*
+ * This file is part of the Sindri package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import * as path from 'path';
+
+import { ErrorFormatter } from '@valkyrjaio/valkyrja/Cli/Interaction/Formatter/ErrorFormatter.ts';
+import { HighlightedTextFormatter } from '@valkyrjaio/valkyrja/Cli/Interaction/Formatter/HighlightedTextFormatter.ts';
+import { SuccessFormatter } from '@valkyrjaio/valkyrja/Cli/Interaction/Formatter/SuccessFormatter.ts';
+import { WarningFormatter } from '@valkyrjaio/valkyrja/Cli/Interaction/Formatter/WarningFormatter.ts';
+import { Header } from '@valkyrjaio/valkyrja/Cli/Interaction/Message/Header.ts';
+import { Message } from '@valkyrjaio/valkyrja/Cli/Interaction/Message/Message.ts';
+import { NewLine } from '@valkyrjaio/valkyrja/Cli/Interaction/Message/NewLine.ts';
+
+import { ConfigReader } from '../../Ast/ConfigReader.ts';
+import { ConfigSourceReader } from '../../Ast/ConfigSourceReader.ts';
+import { ConfigImport } from '../../Ast/Data/ConfigImport.ts';
+import { ConfigSourceResult } from '../../Ast/Data/Result/ConfigSourceResult.ts';
+import { SindriInfo } from '../../Constant/SindriInfo.ts';
+import { AstCachedConfigFileGenerator } from '../../Generator/Ast/Config/AstCachedConfigFileGenerator.ts';
+import { GenerateStatus } from '../../Generator/Enum/GenerateStatus.ts';
+import { GenerateFromAst } from './GenerateFromAst.ts';
+
+import type { ConfigReaderContract } from '../../Ast/Contract/ConfigReaderContract.ts';
+import type { ConfigSourceReaderContract } from '../../Ast/Contract/ConfigSourceReaderContract.ts';
+import type { CachedConfigFileGeneratorContract } from '../../Generator/Config/Contract/CachedConfigFileGeneratorContract.ts';
+import type { OutputContract } from '@valkyrjaio/valkyrja/Cli/Interaction/Output/Contract/OutputContract.ts';
+import type { OutputFactoryContract } from '@valkyrjaio/valkyrja/Cli/Interaction/Output/Factory/Contract/OutputFactoryContract.ts';
+import type { RouteContract } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts';
+
+/**
+ * Writes a cached config beside an application config.
+ *
+ * This is an opt-in command, separate from data generation. An application only
+ * needs a cached config when it starts often enough for module loading to
+ * matter — a CGI or lambda deployment, a CLI command, or a cron job. A worker
+ * process pays that cost one time and gains nothing.
+ */
+export abstract class GenerateCachedConfigFromAst extends GenerateFromAst {
+    /** The container data class the generated config publishes. */
+    protected static readonly CONTAINER_DATA_CLASS = 'AppContainerData';
+
+    /** The name the generated config file takes. */
+    protected static readonly GENERATED_CLASS = 'CachedConfig';
+
+    public constructor(
+        protected readonly outputFactory: OutputFactoryContract,
+        protected readonly route: RouteContract,
+        protected readonly title: string = 'Generating Cached Config From Config',
+        protected readonly configReader: ConfigReaderContract = new ConfigReader(),
+        protected readonly configSourceReader: ConfigSourceReaderContract = new ConfigSourceReader(),
+        protected readonly cachedConfigGenerator: CachedConfigFileGeneratorContract = new AstCachedConfigFileGenerator(),
+    ) {
+        super();
+    }
+
+    protected generateCachedConfig(): OutputContract {
+        let output = this.getOutput();
+
+        const configFilePath = this.getConfigFilePath();
+        const config = this.configReader.readFile(configFilePath);
+        const source = this.configSourceReader.readFile(configFilePath);
+
+        output = output
+            .withAddedMessages(new Message('Generating Cached Config.......................'))
+            .writeMessages();
+
+        if (source.className === '' || config.dataPath === '') {
+            return this.addMessagesForGenerateStatus(output, GenerateStatus.FAILURE)
+                .withAddedMessages(new NewLine())
+                .writeMessages();
+        }
+
+        const outputDirectory = path.dirname(configFilePath);
+        const status = this.cachedConfigGenerator.generateFile(
+            outputDirectory,
+            GenerateCachedConfigFromAst.GENERATED_CLASS,
+            this.withResolvedImports(source, outputDirectory),
+            GenerateCachedConfigFromAst.CONTAINER_DATA_CLASS,
+            this.importSpecifier(
+                outputDirectory,
+                path.join(config.dataPath, `${GenerateCachedConfigFromAst.CONTAINER_DATA_CLASS}.ts`),
+            ),
+        );
+
+        return this.addMessagesForGenerateStatus(output, status)
+            .withAddedMessages(new NewLine())
+            .writeMessages()
+            .withAddedMessages(new NewLine());
+    }
+
+    /**
+     * Rewrite each copied import for the generated file's location.
+     *
+     * A relative specifier only means something next to the file that declared
+     * it. An import copied out of a framework config base points at the
+     * framework directory, so it must be written again as the package specifier
+     * or as a path relative to the output directory.
+     */
+    protected withResolvedImports(source: ConfigSourceResult, outputDirectory: string): ConfigSourceResult {
+        const imports = source.imports.map((entry) =>
+            entry.resolvedPath === ''
+                ? entry
+                : new ConfigImport(
+                      entry.name,
+                      this.importSpecifier(outputDirectory, entry.resolvedPath),
+                      entry.isType,
+                      entry.resolvedPath,
+                  ),
+        );
+
+        return new ConfigSourceResult(
+            source.className,
+            source.contractName,
+            source.contractSpecifier,
+            source.fields,
+            source.types,
+            imports,
+        );
+    }
+
+    protected getOutput(): OutputContract {
+        return this.outputFactory
+            .createOutput()
+            .withAddedMessages(
+                new Header('Sindri', SindriInfo.VERSION, this.route, SindriInfo.ICON),
+                new NewLine(),
+                new NewLine(),
+                new Message(`${this.title}:`, new HighlightedTextFormatter()),
+                new NewLine(),
+                new NewLine(),
+            )
+            .writeMessages();
+    }
+
+    protected addMessagesForGenerateStatus(output: OutputContract, status: GenerateStatus): OutputContract {
+        let text = 'Failed';
+        let formatter = new ErrorFormatter();
+
+        if (status === GenerateStatus.SUCCESS) {
+            text = 'Success';
+            formatter = new SuccessFormatter();
+        }
+
+        if (status === GenerateStatus.SKIPPED) {
+            text = 'Skipped';
+            formatter = new WarningFormatter();
+        }
+
+        return output.withAddedMessages(new Message(text, formatter), new NewLine());
+    }
+
+    protected abstract getConfigFilePath(): string;
+}