lattice-ui 0.4.3

package/dist/commands/create.js

@@ -0,0 +1,351 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreateCommand = runCreateCommand;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const errors_1 = require("../core/errors");
+const copy_1 = require("../core/fs/copy");
+const logger_1 = require("../core/logger");
+const latest_1 = require("../core/npm/latest");
+const output_1 = require("../core/output");
+const detect_1 = require("../core/pm/detect");
+const prompt_1 = require("../core/prompt");
+const SUPPORTED_TEMPLATE = "rbxts";
+const CORE_VERSION_PACKAGES = {
+    latticeStyle: "@lattice-ui/style",
+    latticeCli: "@lattice-ui/cli",
+    rbxtsReact: "@rbxts/react",
+    rbxtsReactRoblox: "@rbxts/react-roblox",
+    rbxtsCompilerTypes: "@rbxts/compiler-types",
+    rbxtsTypes: "@rbxts/types",
+    robloxTs: "roblox-ts",
+    typescript: "typescript",
+};
+const LINT_VERSION_PACKAGES = {
+    eslint: "eslint",
+    eslintEslintrc: "@eslint/eslintrc",
+    eslintJs: "@eslint/js",
+    eslintConfigPrettier: "eslint-config-prettier",
+    eslintPluginPrettier: "eslint-plugin-prettier",
+    eslintPluginRobloxTs: "eslint-plugin-roblox-ts",
+    typescriptEslintPlugin: "@typescript-eslint/eslint-plugin",
+    typescriptEslintParser: "@typescript-eslint/parser",
+    prettier: "prettier",
+};
+const GITIGNORE_ENTRIES = [
+    "node_modules",
+    "out",
+    "include",
+    "*.rbxl",
+    "*.rbxlx",
+    "*.rbxm",
+    "*.rbxmx",
+    "*.rbxl.lock",
+    "*.rbxlx.lock",
+    "*.rbxm.lock",
+    "*.rbxmx.lock",
+    "*.tsbuildinfo",
+    ".pnpm-store",
+    ".DS_Store",
+];
+const GITIGNORE_CONTENT = `${GITIGNORE_ENTRIES.join("\n")}\n`;
+const PROJECT_DIRECTORIES = ["include", "out/shared", "out/server", "out/client"];
+const PNPM_NPMRC_PATH = ".npmrc";
+const PNPM_NODE_LINKER_LINE = "node-linker=hoisted";
+function inferPackageName(projectRoot) {
+    const baseName = path.basename(projectRoot);
+    const normalized = baseName
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "")
+        .replace(/-{2,}/g, "-");
+    return normalized.length > 0 ? normalized : "lattice-app";
+}
+function normalizeProjectPath(projectPath) {
+    const trimmed = projectPath.trim();
+    if (trimmed.length === 0) {
+        throw (0, errors_1.usageError)("create requires a non-empty <project-path>.");
+    }
+    if (path.isAbsolute(trimmed)) {
+        throw (0, errors_1.usageError)("create only accepts relative project paths.");
+    }
+    const normalized = path.normalize(trimmed);
+    const parts = normalized.split(path.sep).filter((part) => part.length > 0);
+    if (parts.length === 0 || parts.some((part) => part === "." || part === "..")) {
+        throw (0, errors_1.usageError)("create does not allow '.', '..', or parent-relative paths.");
+    }
+    return normalized;
+}
+async function ensureEmptyDirectory(targetRoot) {
+    try {
+        const stat = await node_fs_1.promises.stat(targetRoot);
+        if (!stat.isDirectory()) {
+            throw (0, errors_1.usageError)(`Target path exists and is not a directory: ${targetRoot}`);
+        }
+        const entries = await node_fs_1.promises.readdir(targetRoot);
+        if (entries.length > 0) {
+            throw (0, errors_1.usageError)(`Target directory must be empty: ${targetRoot}`);
+        }
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+        await node_fs_1.promises.mkdir(targetRoot, { recursive: true });
+    }
+}
+async function runProcess(command, args, cwd) {
+    await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (error) => {
+            reject((0, errors_1.packageManagerFailedError)(`Failed to run ${command}: ${error.message}`, error));
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject((0, errors_1.packageManagerFailedError)(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+        });
+    });
+}
+async function ensureGitignoreExists(targetRoot) {
+    const gitignorePath = path.join(targetRoot, ".gitignore");
+    try {
+        await node_fs_1.promises.access(gitignorePath);
+    }
+    catch {
+        await node_fs_1.promises.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf8");
+    }
+}
+async function ensureProjectDirectories(targetRoot) {
+    await Promise.all(PROJECT_DIRECTORIES.map((directory) => node_fs_1.promises.mkdir(path.join(targetRoot, directory), { recursive: true })));
+}
+function normalizeTemplate(template) {
+    const value = template?.trim();
+    if (!value || value.length === 0) {
+        return SUPPORTED_TEMPLATE;
+    }
+    return value;
+}
+async function ensurePnpmNodeLinkerConfig(targetRoot, packageManager) {
+    if (packageManager !== "pnpm") {
+        return;
+    }
+    const npmrcPath = path.join(targetRoot, PNPM_NPMRC_PATH);
+    try {
+        const currentContent = await node_fs_1.promises.readFile(npmrcPath, "utf8");
+        const eol = currentContent.includes("\r\n") ? "\r\n" : "\n";
+        const lines = currentContent.split(/\r?\n/);
+        const nodeLinkerIndex = lines.findIndex((line) => /^\s*node-linker\s*=/.test(line));
+        if (nodeLinkerIndex >= 0) {
+            if (lines[nodeLinkerIndex].trim() === PNPM_NODE_LINKER_LINE) {
+                return;
+            }
+            lines[nodeLinkerIndex] = PNPM_NODE_LINKER_LINE;
+            await node_fs_1.promises.writeFile(npmrcPath, lines.join(eol), "utf8");
+            return;
+        }
+        const nextContent = currentContent.endsWith("\n")
+            ? `${currentContent}${PNPM_NODE_LINKER_LINE}${eol}`
+            : `${currentContent}${eol}${PNPM_NODE_LINKER_LINE}${eol}`;
+        await node_fs_1.promises.writeFile(npmrcPath, nextContent, "utf8");
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+        await node_fs_1.promises.writeFile(npmrcPath, `${PNPM_NODE_LINKER_LINE}\n`, "utf8");
+    }
+}
+async function selectTemplate(providedTemplate) {
+    const normalized = normalizeTemplate(providedTemplate);
+    if (normalized !== SUPPORTED_TEMPLATE) {
+        throw (0, errors_1.usageError)(`Unknown template: ${normalized}. Supported template: ${SUPPORTED_TEMPLATE}.`);
+    }
+    return normalized;
+}
+async function selectGitEnabled(runtime, providedGit) {
+    if (providedGit !== undefined) {
+        return providedGit;
+    }
+    return (0, prompt_1.promptConfirm)(runtime, "Initialize a git repository?", { defaultValue: false });
+}
+async function selectLintEnabled(runtime, providedLint) {
+    if (providedLint !== undefined) {
+        return providedLint;
+    }
+    if (runtime.yes) {
+        return true;
+    }
+    return (0, prompt_1.promptConfirm)(runtime, "Set up ESLint + Prettier?", { defaultValue: true });
+}
+async function resolveProjectPath(runtime, projectPath, promptInputFn) {
+    const value = projectPath?.trim();
+    if (value && value.length > 0) {
+        return value;
+    }
+    if (runtime.yes) {
+        throw (0, errors_1.usageError)("create requires [project-path] when using --yes.");
+    }
+    return promptInputFn(runtime, "What is your project named?", { required: true });
+}
+async function runCreateCommand(input, runtimeOverrides) {
+    const detectPackageManagerFn = runtimeOverrides?.detectPackageManagerFn ?? detect_1.detectPackageManager;
+    const resolveLatestVersionsFn = runtimeOverrides?.resolveLatestVersionsFn ?? latest_1.resolveLatestVersions;
+    const runProcessFn = runtimeOverrides?.runProcessFn ?? runProcess;
+    const createLoggerFn = runtimeOverrides?.createLoggerFn ?? logger_1.createLogger;
+    const promptInputFn = runtimeOverrides?.promptInputFn ?? prompt_1.promptInput;
+    const promptSelectFn = runtimeOverrides?.promptSelectFn ?? prompt_1.promptSelect;
+    const runtime = { yes: input.yes };
+    const template = await selectTemplate(input.template);
+    if (template !== SUPPORTED_TEMPLATE) {
+        throw (0, errors_1.usageError)(`Unsupported template: ${template}`);
+    }
+    const gitEnabled = await selectGitEnabled(runtime, input.git);
+    const lintEnabled = await selectLintEnabled(runtime, input.lint);
+    const providedProjectPath = await resolveProjectPath(runtime, input.projectPath, promptInputFn);
+    const relativeProjectPath = normalizeProjectPath(providedProjectPath);
+    const targetRoot = path.resolve(input.cwd, relativeProjectPath);
+    await ensureEmptyDirectory(targetRoot);
+    const logger = createLoggerFn({
+        verbose: false,
+        yes: input.yes,
+    });
+    const resolvedPm = await detectPackageManagerFn(targetRoot, input.pm, {
+        runtime,
+        promptSelectFn,
+    });
+    let packageManagerSourceLabel;
+    switch (resolvedPm.source) {
+        case "override":
+            packageManagerSourceLabel = "explicit --pm";
+            break;
+        case "lockfile":
+            packageManagerSourceLabel = "lockfile";
+            break;
+        case "installed":
+            packageManagerSourceLabel = "only installed package manager";
+            break;
+        case "prompt":
+            packageManagerSourceLabel = "interactive selection";
+            break;
+    }
+    logger.section("Creating a new Lattice app");
+    logger.kv("Location", targetRoot);
+    logger.kv("Template", template);
+    logger.kv("Resolved package manager", resolvedPm.name);
+    logger.kv("Package manager source", packageManagerSourceLabel);
+    logger.kv("Git", gitEnabled ? "enabled" : "disabled (use --git to enable)");
+    logger.kv("Lint/format", lintEnabled ? "enabled" : "disabled");
+    logger.section("Resolving");
+    const versionSpinner = logger.spinner("Resolving latest package versions...");
+    const packagesToResolve = [
+        ...Object.values(CORE_VERSION_PACKAGES),
+        ...(lintEnabled ? Object.values(LINT_VERSION_PACKAGES) : []),
+    ];
+    const versions = await resolveLatestVersionsFn(packagesToResolve);
+    versionSpinner.succeed("Package versions resolved.");
+    const templateDir = path.resolve(__dirname, "../../templates/init");
+    logger.section("Scaffolding");
+    const scaffoldSpinner = logger.spinner(`Scaffolding ${template} template...`);
+    const report = await (0, copy_1.copyTemplateSafe)(templateDir, targetRoot, {
+        dryRun: false,
+        logger,
+        replacements: {
+            __PROJECT_NAME__: inferPackageName(targetRoot),
+            __LATTICE_STYLE_VERSION__: versions[CORE_VERSION_PACKAGES.latticeStyle],
+            __LATTICE_CLI_VERSION__: versions[CORE_VERSION_PACKAGES.latticeCli],
+            __RBXTS_REACT_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsReact],
+            __RBXTS_REACT_ROBLOX_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsReactRoblox],
+            __RBXTS_COMPILER_TYPES_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsCompilerTypes],
+            __RBXTS_TYPES_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsTypes],
+            __ROBLOX_TS_VERSION__: versions[CORE_VERSION_PACKAGES.robloxTs],
+            __TYPESCRIPT_VERSION__: versions[CORE_VERSION_PACKAGES.typescript],
+        },
+    });
+    scaffoldSpinner.succeed(`Scaffold complete (${report.created.length} created, ${report.merged.length} merged).`);
+    if (lintEnabled) {
+        logger.section("Configuring");
+        const lintTemplateDir = path.resolve(__dirname, "../../templates/init-lint");
+        const lintSpinner = logger.spinner("Applying ESLint + Prettier configuration...");
+        await (0, copy_1.copyTemplateSafe)(lintTemplateDir, targetRoot, {
+            dryRun: false,
+            logger,
+            replacements: {
+                __ESLINT_VERSION__: versions[LINT_VERSION_PACKAGES.eslint],
+                __ESLINT_ESLINTRC_VERSION__: versions[LINT_VERSION_PACKAGES.eslintEslintrc],
+                __ESLINT_JS_VERSION__: versions[LINT_VERSION_PACKAGES.eslintJs],
+                __ESLINT_CONFIG_PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.eslintConfigPrettier],
+                __ESLINT_PLUGIN_PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.eslintPluginPrettier],
+                __ESLINT_PLUGIN_ROBLOX_TS_VERSION__: versions[LINT_VERSION_PACKAGES.eslintPluginRobloxTs],
+                __TYPESCRIPT_ESLINT_PLUGIN_VERSION__: versions[LINT_VERSION_PACKAGES.typescriptEslintPlugin],
+                __TYPESCRIPT_ESLINT_PARSER_VERSION__: versions[LINT_VERSION_PACKAGES.typescriptEslintParser],
+                __PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.prettier],
+            },
+        });
+        lintSpinner.succeed("Lint and format configuration applied.");
+    }
+    await ensureProjectDirectories(targetRoot);
+    await ensureGitignoreExists(targetRoot);
+    await ensurePnpmNodeLinkerConfig(targetRoot, resolvedPm.name);
+    logger.section("Installing");
+    const installSpinner = logger.spinner(`Installing dependencies with ${resolvedPm.name}...`);
+    await resolvedPm.manager.install(targetRoot);
+    installSpinner.succeed("Dependencies installed.");
+    if (gitEnabled) {
+        logger.section("Git");
+        const gitSpinner = logger.spinner("Initializing git repository...");
+        await runProcessFn("git", ["init"], targetRoot);
+        gitSpinner.succeed("Git repository initialized.");
+    }
+    logger.success(`Success! Created ${path.basename(targetRoot)} at ${targetRoot}`);
+    logger.kv("Files created", String(report.created.length));
+    logger.kv("Files merged", String(report.merged.length));
+    logger.section("Next Steps");
+    logger.step(`cd ${relativeProjectPath}`);
+    logger.step(`${resolvedPm.name} run build`);
+    logger.step(`${(0, output_1.resolveLocalLatticeCommand)(resolvedPm.name)} add --preset form`);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { CliContext } from "../ctx";
+export declare function runDoctorCommand(ctx: CliContext): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctorCommand = runDoctorCommand;
+const errors_1 = require("../core/errors");
+const patch_1 = require("../core/fs/patch");
+const output_1 = require("../core/output");
+const readPackageJson_1 = require("../core/project/readPackageJson");
+const schema_1 = require("../core/registry/schema");
+const LATTICE_TOOLING_PACKAGES = new Set(["@lattice-ui/cli"]);
+function collectRecommendations(issues, pmName) {
+    const recommendationSet = new Set();
+    const localLattice = (0, output_1.resolveLocalLatticeCommand)(pmName);
+    for (const issue of issues) {
+        switch (issue.code) {
+            case "missing-lockfile":
+                recommendationSet.add(`${pmName} install`);
+                break;
+            case "multiple-lockfiles":
+                recommendationSet.add("Remove extra lockfiles and keep exactly one package manager lockfile.");
+                break;
+            case "package-manager-mismatch":
+                recommendationSet.add("Update package.json packageManager to match the active lockfile manager.");
+                break;
+            case "missing-lattice-packages":
+                recommendationSet.add(`${localLattice} add <component>`);
+                break;
+            case "unknown-lattice-package":
+                recommendationSet.add(`${localLattice} upgrade`);
+                break;
+            case "missing-peer":
+            case "missing-required-provider":
+                recommendationSet.add(`${localLattice} add <component>`);
+                break;
+            case "missing-optional-provider":
+                recommendationSet.add(`${localLattice} add <component>`);
+                break;
+            default:
+                break;
+        }
+    }
+    return [...recommendationSet];
+}
+async function runDoctorCommand(ctx) {
+    ctx.logger.section("Checking");
+    ctx.logger.kv("Project", ctx.projectRoot);
+    ctx.logger.kv("Resolved package manager", ctx.pmName);
+    const manifest = await (0, readPackageJson_1.readPackageJson)(ctx.projectRoot);
+    const installedDependencies = (0, patch_1.getDependencyNames)(manifest);
+    const issues = [];
+    if (ctx.detectedLockfiles.length === 0) {
+        issues.push({
+            code: "missing-lockfile",
+            level: "warn",
+            message: `No lockfile found. Resolved package manager is ${ctx.pmName}.`,
+        });
+    }
+    if (ctx.detectedLockfiles.length > 1) {
+        issues.push({
+            code: "multiple-lockfiles",
+            level: "warn",
+            message: `Multiple lockfiles detected: ${ctx.detectedLockfiles.join(", ")}. Using ${ctx.pmName}.`,
+        });
+    }
+    if (typeof manifest.packageManager === "string" && manifest.packageManager.length > 0) {
+        const normalized = manifest.packageManager.split("@")[0];
+        if (normalized !== ctx.pmName) {
+            issues.push({
+                code: "package-manager-mismatch",
+                level: "warn",
+                message: `packageManager field is ${manifest.packageManager} but resolved ${ctx.pmName}.`,
+            });
+        }
+    }
+    const installedLattice = [...installedDependencies]
+        .filter((name) => name.startsWith("@lattice-ui/"))
+        .sort((left, right) => left.localeCompare(right));
+    const installedLatticeComponents = installedLattice.filter((name) => !LATTICE_TOOLING_PACKAGES.has(name));
+    if (installedLatticeComponents.length === 0) {
+        issues.push({
+            code: "missing-lattice-packages",
+            level: "warn",
+            message: "No @lattice-ui component packages are installed.",
+        });
+    }
+    const componentByNpm = new Map();
+    for (const [componentName, entry] of Object.entries(ctx.registry.packages)) {
+        componentByNpm.set(entry.npm, componentName);
+    }
+    for (const npmPackage of installedLatticeComponents) {
+        const componentName = componentByNpm.get(npmPackage);
+        if (!componentName) {
+            issues.push({
+                code: "unknown-lattice-package",
+                level: "warn",
+                message: `${npmPackage} is installed but not found in CLI registry.`,
+            });
+            continue;
+        }
+        const entry = ctx.registry.packages[componentName];
+        for (const peer of entry.peers ?? []) {
+            if (!installedDependencies.has(peer)) {
+                issues.push({
+                    code: "missing-peer",
+                    level: "warn",
+                    message: `${componentName} expects peer ${peer}, but it is not installed.`,
+                });
+            }
+        }
+        for (const rawProvider of entry.providers ?? []) {
+            const provider = (0, schema_1.parseProviderRequirement)(rawProvider);
+            if (installedDependencies.has(provider.packageName)) {
+                continue;
+            }
+            if (provider.optional) {
+                issues.push({
+                    code: "missing-optional-provider",
+                    level: "warn",
+                    message: `${componentName} optional provider not found: ${provider.raw}`,
+                });
+            }
+            else {
+                issues.push({
+                    code: "missing-required-provider",
+                    level: "error",
+                    message: `${componentName} required provider missing: ${provider.raw}`,
+                });
+            }
+        }
+    }
+    const warnings = issues.filter((issue) => issue.level === "warn");
+    const errors = issues.filter((issue) => issue.level === "error");
+    ctx.logger.section("Summary");
+    ctx.logger.kv("Errors", String(errors.length));
+    ctx.logger.kv("Warnings", String(warnings.length));
+    if (warnings.length > 0) {
+        ctx.logger.section("Warnings");
+        ctx.logger.list(warnings.map((issue) => issue.message));
+    }
+    if (errors.length > 0) {
+        ctx.logger.section("Errors");
+        ctx.logger.list(errors.map((issue) => issue.message));
+    }
+    const recommendations = collectRecommendations(issues, ctx.pmName);
+    if (recommendations.length > 0) {
+        ctx.logger.section("Recommended Commands");
+        const recommendationSummary = (0, output_1.summarizeItems)(recommendations);
+        ctx.logger.list(recommendationSummary.visible);
+        if (recommendationSummary.hidden > 0) {
+            ctx.logger.step(`...and ${recommendationSummary.hidden} more`);
+        }
+    }
+    ctx.logger.section("Result");
+    if (errors.length > 0) {
+        const message = `doctor found ${errors.length} error(s) and ${warnings.length} warning(s).`;
+        ctx.logger.error(message);
+        throw (0, errors_1.validationError)(message);
+    }
+    if (warnings.length > 0) {
+        ctx.logger.success(`doctor completed with ${warnings.length} warning(s).`);
+    }
+    else {
+        ctx.logger.success("doctor found no issues.");
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,21 @@
+import { createLogger } from "../core/logger";
+import { resolveLatestVersions } from "../core/npm/latest";
+import { detectPackageManager } from "../core/pm/detect";
+import { promptConfirm, promptSelect } from "../core/prompt";
+export interface InitCommandInput {
+    cwd: string;
+    pm?: string;
+    yes: boolean;
+    dryRun: boolean;
+    template?: string;
+    lint?: boolean;
+}
+interface InitCommandRuntimeOverrides {
+    detectPackageManagerFn?: typeof detectPackageManager;
+    resolveLatestVersionsFn?: typeof resolveLatestVersions;
+    createLoggerFn?: typeof createLogger;
+    promptSelectFn?: typeof promptSelect;
+    promptConfirmFn?: typeof promptConfirm;
+}
+export declare function runInitCommand(input: InitCommandInput, runtimeOverrides?: InitCommandRuntimeOverrides): Promise<void>;
+export {};