@vobs/cli 0.3.0 → 1.2.0

package/dist/inspect.js

@@ -1,576 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/cli
- */
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { analyzeView, checkViewProject } from '@vobs/compiler-dom';
-const ignoredDirectories = new Set(['.git', '.cache', '.tmp', 'coverage', 'dist', 'node_modules']);
-export function inspectVobsProject(options) {
-    const tsconfigPath = path.resolve(options.tsconfigPath);
-    const projectRoot = path.dirname(tsconfigPath);
-    const workspaceRoot = findWorkspaceRoot(projectRoot);
-    const rootPackage = readJsonFile(path.join(workspaceRoot, 'package.json'));
-    const projectPackage = readJsonFile(path.join(projectRoot, 'package.json'));
-    const config = readTsConfig(tsconfigPath, projectRoot);
-    const files = collectProjectFiles(projectRoot);
-    const routeRoot = path.join(projectRoot, 'src', 'pages');
-    const routes = collectRoutes(routeRoot, projectRoot);
-    const checkResult = checkViewProject({ tsconfigPath });
-    return {
-        schemaVersion: '0.1',
-        generatedBy: 'vobs inspect',
-        workspace: {
-            root: manifestPath(workspaceRoot, workspaceRoot),
-            ...(typeof rootPackage?.packageManager === 'string'
-                ? { packageManager: rootPackage.packageManager }
-                : {}),
-        },
-        project: {
-            root: manifestPath(projectRoot, workspaceRoot),
-            ...(typeof projectPackage?.name === 'string' ? { name: projectPackage.name } : {}),
-            ...(typeof projectPackage?.name === 'string' ? { packageName: projectPackage.name } : {}),
-            ...(typeof projectPackage?.version === 'string'
-                ? { packageVersion: projectPackage.version }
-                : {}),
-        },
-        tsconfig: {
-            path: manifestPath(tsconfigPath, workspaceRoot),
-            rootNames: config.fileNames.map((fileName) => manifestPath(fileName, workspaceRoot)),
-            references: (config.projectReferences ?? []).map((reference) => manifestPath(reference.path, workspaceRoot)),
-        },
-        packages: collectPackages(workspaceRoot),
-        files: {
-            views: files.views.map((view) => manifestPath(view.file, workspaceRoot)),
-            routes: routes.map((route) => toManifestRoute(route, workspaceRoot)),
-            components: files.components.map((component) => toManifestComponent(component, workspaceRoot)),
-            globalComponents: checkResult.globalComponentTags ?? [],
-            viewContracts: files.views.map((view) => toManifestView(view, workspaceRoot)),
-            authorization: files.authorization.map((file) => toManifestPermission(file, workspaceRoot)),
-        },
-        diagnostics: checkResult.diagnostics.map((diagnostic) => toManifestDiagnostic(diagnostic, workspaceRoot)),
-    };
-}
-export function writeInspectOutput(manifest, outputPath) {
-    const workingDirectory = path.resolve(process.cwd());
-    const target = path.resolve(workingDirectory, outputPath);
-    const relativeTarget = path.relative(workingDirectory, target);
-    if (relativeTarget === '' ||
-        relativeTarget.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relativeTarget)) {
-        throw new Error(`Refusing to write inspect output outside the current directory: ${target}`);
-    }
-    const fileName = path.basename(target).toLowerCase();
-    if (fileName === '' || /(?:^|[._-])(?:env|secret|token|credential|password)/u.test(fileName)) {
-        throw new Error(`Refusing to write inspect output to a sensitive filename: ${target}`);
-    }
-    mkdirSync(path.dirname(target), { recursive: true });
-    writeFileSync(target, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
-}
-function collectProjectFiles(root) {
-    const views = [];
-    const components = [];
-    const authorization = [];
-    for (const fileName of walkFiles(root)) {
-        if (fileName.endsWith('.html')) {
-            views.push({ file: fileName, ...analyzeView(readFileSync(fileName, 'utf8'), fileName) });
-        }
-        if (!isTypeScriptFile(fileName))
-            continue;
-        const source = readFileSync(fileName, 'utf8');
-        const component = readComponentFile(fileName, source);
-        if (component !== undefined)
-            components.push(component);
-        const permission = readPermissionFile(fileName, source);
-        if (permission !== undefined)
-            authorization.push(permission);
-    }
-    views.sort((left, right) => left.file.localeCompare(right.file));
-    components.sort((left, right) => left.file.localeCompare(right.file));
-    authorization.sort((left, right) => left.file.localeCompare(right.file));
-    return { views, components, authorization };
-}
-function readComponentFile(fileName, source) {
-    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
-    const definition = findDefinitionCall(sourceFile);
-    if (definition === undefined)
-        return undefined;
-    const viewRequest = readHtmlImport(sourceFile);
-    const view = viewRequest === undefined ? undefined : path.resolve(path.dirname(fileName), viewRequest);
-    return {
-        kind: definition.kind,
-        file: fileName,
-        ...(view === undefined ? {} : { view }),
-        exports: readExportNames(source),
-        props: readStaticArrayProperty(definition.options, 'props'),
-        emits: readStaticArrayProperty(definition.options, 'emits'),
-        exposed: readSetupExposedNames(definition.options, sourceFile),
-        registeredComponents: readStaticObjectKeys(definition.options, 'components'),
-    };
-}
-function findDefinitionCall(sourceFile) {
-    let result;
-    const visit = (node) => {
-        if (result === undefined &&
-            ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            (node.expression.text === 'definePage' || node.expression.text === 'defineComponent')) {
-            const options = node.arguments[0];
-            if (options !== undefined && ts.isObjectLiteralExpression(options)) {
-                result = {
-                    kind: node.expression.text === 'definePage' ? 'page' : 'component',
-                    options,
-                };
-                return;
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    return result;
-}
-function readHtmlImport(sourceFile) {
-    for (const statement of sourceFile.statements) {
-        if (ts.isImportDeclaration(statement) &&
-            ts.isStringLiteral(statement.moduleSpecifier) &&
-            statement.moduleSpecifier.text.endsWith('.html')) {
-            return statement.moduleSpecifier.text;
-        }
-    }
-    return undefined;
-}
-function readStaticArrayProperty(options, name) {
-    const expression = readPropertyExpression(options, name);
-    const array = expression === undefined ? undefined : unwrapExpression(expression);
-    if (array === undefined || !ts.isArrayLiteralExpression(array))
-        return [];
-    return array.elements
-        .map((element) => (ts.isStringLiteral(element) ? element.text : undefined))
-        .filter((value) => value !== undefined)
-        .sort();
-}
-function readStaticObjectKeys(options, name) {
-    const expression = readPropertyExpression(options, name);
-    const object = expression === undefined ? undefined : unwrapExpression(expression);
-    if (object === undefined || !ts.isObjectLiteralExpression(object))
-        return [];
-    return object.properties
-        .map(readObjectElementName)
-        .filter((value) => value !== undefined)
-        .sort();
-}
-function readSetupExposedNames(options, sourceFile) {
-    const setup = findSetupFunction(options, sourceFile);
-    const body = setup !== undefined && 'body' in setup ? setup.body : undefined;
-    if (body === undefined)
-        return [];
-    const names = new Set();
-    if (!ts.isBlock(body)) {
-        const expression = unwrapExpression(body);
-        if (ts.isObjectLiteralExpression(expression))
-            collectObjectKeys(expression, names);
-    }
-    const visit = (node) => {
-        if (node !== body && ts.isFunctionLike(node))
-            return;
-        if (ts.isReturnStatement(node) && node.expression !== undefined) {
-            const expression = unwrapExpression(node.expression);
-            if (ts.isObjectLiteralExpression(expression))
-                collectObjectKeys(expression, names);
-        }
-        if (ts.isCallExpression(node) && isExposeCall(node.expression)) {
-            const argument = node.arguments[0];
-            if (argument !== undefined) {
-                const expression = unwrapExpression(argument);
-                if (ts.isObjectLiteralExpression(expression))
-                    collectObjectKeys(expression, names);
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    if (ts.isBlock(body))
-        visit(body);
-    return [...names].sort();
-}
-function findSetupFunction(options, sourceFile) {
-    for (const property of options.properties) {
-        if (readPropertyName(property.name) !== 'setup')
-            continue;
-        if (ts.isMethodDeclaration(property))
-            return property;
-        if (ts.isShorthandPropertyAssignment(property)) {
-            return findTopLevelFunction(sourceFile, property.name.text);
-        }
-        if (ts.isPropertyAssignment(property)) {
-            const initializer = unwrapExpression(property.initializer);
-            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
-                return initializer;
-            }
-            if (ts.isIdentifier(initializer))
-                return findTopLevelFunction(sourceFile, initializer.text);
-        }
-    }
-    return undefined;
-}
-function findTopLevelFunction(sourceFile, name) {
-    for (const statement of sourceFile.statements) {
-        if (ts.isFunctionDeclaration(statement) && statement.name?.text === name)
-            return statement;
-        if (!ts.isVariableStatement(statement))
-            continue;
-        for (const declaration of statement.declarationList.declarations) {
-            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name)
-                continue;
-            const initializer = declaration.initializer === undefined
-                ? undefined
-                : unwrapExpression(declaration.initializer);
-            if (initializer !== undefined &&
-                (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) {
-                return initializer;
-            }
-        }
-    }
-    return undefined;
-}
-function isExposeCall(expression) {
-    return ((ts.isIdentifier(expression) && expression.text === 'expose') ||
-        (ts.isPropertyAccessExpression(expression) && expression.name.text === 'expose'));
-}
-function collectObjectKeys(object, names) {
-    for (const property of object.properties) {
-        const name = readObjectElementName(property);
-        if (name !== undefined)
-            names.add(name);
-    }
-}
-function readPropertyExpression(object, name) {
-    for (const property of object.properties) {
-        if (readPropertyName(property.name) !== name)
-            continue;
-        if (ts.isPropertyAssignment(property))
-            return property.initializer;
-    }
-    return undefined;
-}
-function readPropertyName(name) {
-    if (name === undefined)
-        return undefined;
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
-        return name.text;
-    }
-    return undefined;
-}
-function readObjectElementName(property) {
-    return ts.isSpreadAssignment(property) ? undefined : readPropertyName(property.name);
-}
-function unwrapExpression(expression) {
-    let current = expression;
-    while (ts.isParenthesizedExpression(current) ||
-        ts.isAsExpression(current) ||
-        ts.isSatisfiesExpression(current) ||
-        ts.isNonNullExpression(current)) {
-        current = current.expression;
-    }
-    return current;
-}
-function readPermissionFile(fileName, source) {
-    const exportedSymbols = readExportNames(source);
-    const kinds = [];
-    const authorizerOptions = readAuthorizerOptionNames(fileName, source);
-    if (authorizerOptions !== undefined ||
-        exportedSymbols.some((name) => /authorization|authorizer|permission/iu.test(name))) {
-        kinds.push('authorization');
-    }
-    if (authorizerOptions?.has('roles') === true ||
-        exportedSymbols.some((name) => /^roles?$/iu.test(name) || /^AuthorizationRole/u.test(name))) {
-        kinds.push('role');
-    }
-    if (authorizerOptions?.has('policies') === true ||
-        exportedSymbols.some((name) => /^polic(?:y|ies)$/iu.test(name) || /^AuthorizationPolicy/u.test(name))) {
-        kinds.push('policy');
-    }
-    if (kinds.length === 0)
-        return undefined;
-    return {
-        file: fileName,
-        kinds,
-        symbols: exportedSymbols.filter((name) => /authorization|authorizer|permission|roles?|polic(?:y|ies)/iu.test(name)),
-    };
-}
-function readAuthorizerOptionNames(fileName, source) {
-    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
-    let options;
-    const visit = (node) => {
-        if (options === undefined &&
-            ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'createAuthorizer') {
-            options = new Set();
-            const argument = node.arguments[0];
-            if (argument !== undefined && ts.isObjectLiteralExpression(argument)) {
-                for (const property of argument.properties) {
-                    if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
-                        ts.isIdentifier(property.name)) {
-                        options.add(property.name.text);
-                    }
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    return options;
-}
-function readExportNames(source) {
-    const names = new Set();
-    if (/\bexport\s+default\b/u.test(source))
-        names.add('default');
-    for (const match of source.matchAll(/\bexport\s+(?:const|let|var|function|class|interface|type)\s+([\w$]+)/gu)) {
-        const name = match[1];
-        if (name !== undefined)
-            names.add(name);
-    }
-    for (const match of source.matchAll(/\bexport\s*\{([^}]*)\}/gu)) {
-        for (const entry of (match[1] ?? '').split(',')) {
-            const exported = /\bas\s+([\w$]+)/u.exec(entry)?.[1] ?? entry.trim();
-            if (exported !== '')
-                names.add(exported);
-        }
-    }
-    return [...names].sort();
-}
-function collectRoutes(root, projectRoot) {
-    if (!existsSync(root) || !statSync(root).isDirectory())
-        return [];
-    const routes = [];
-    walkRouteDirectory(root, root, [], undefined, routes);
-    const notFound = path.join(root, '_404.ts');
-    if (existsSync(notFound)) {
-        routes.push({
-            kind: 'not-found',
-            path: '*',
-            file: notFound,
-            layouts: [],
-            hasGuard: false,
-            hasLoader: false,
-        });
-    }
-    const error = path.join(root, '_error.ts');
-    if (existsSync(error)) {
-        routes.push({
-            kind: 'error',
-            path: 'error',
-            file: error,
-            layouts: [],
-            hasGuard: false,
-            hasLoader: false,
-        });
-    }
-    return routes
-        .filter((route) => route.file.startsWith(projectRoot))
-        .sort((left, right) => left.path.localeCompare(right.path) || left.file.localeCompare(right.file));
-}
-function walkRouteDirectory(directory, pagesRoot, parentLayouts, parentError, routes) {
-    const layout = path.join(directory, '_layout.ts');
-    const layouts = existsSync(layout) ? [...parentLayouts, layout] : parentLayouts;
-    const localError = path.join(directory, '_error.ts');
-    const error = existsSync(localError) ? localError : parentError;
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-        const entryPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-            walkRouteDirectory(entryPath, pagesRoot, layouts, error, routes);
-            continue;
-        }
-        if (!entry.name.endsWith('.ts') || entry.name.endsWith('.d.ts') || entry.name.startsWith('_')) {
-            continue;
-        }
-        const source = readFileSync(entryPath, 'utf8');
-        routes.push({
-            kind: 'page',
-            path: routePathForFile(entryPath, pagesRoot),
-            file: entryPath,
-            layouts,
-            ...(error === undefined ? {} : { error }),
-            hasGuard: hasExportedRouteMember(source, 'guard'),
-            hasLoader: hasExportedRouteMember(source, 'loader'),
-        });
-    }
-}
-function routePathForFile(fileName, pagesRoot) {
-    const relative = path.relative(pagesRoot, fileName).replaceAll(path.sep, '/');
-    const segments = relative
-        .slice(0, -'.ts'.length)
-        .split('/')
-        .flatMap((segment) => {
-        if (segment === 'index')
-            return [];
-        if (segment.startsWith('(') && segment.endsWith(')'))
-            return [];
-        if (segment.startsWith('[...') && segment.endsWith(']'))
-            return [`*${segment.slice(4, -1)}`];
-        if (segment.startsWith('[') && segment.endsWith(']'))
-            return [`:${segment.slice(1, -1)}`];
-        return [segment];
-    });
-    return segments.length === 0 ? '/' : `/${segments.join('/')}`;
-}
-function hasExportedRouteMember(source, name) {
-    return new RegExp(`^\\s*export\\s+(?:(?:async\\s+)?function|const|let|var)\\s+${name}\\b`, 'mu').test(source);
-}
-function walkFiles(root) {
-    const files = [];
-    walk(root, files);
-    return files;
-}
-function walk(directory, files) {
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-            if (!ignoredDirectories.has(entry.name) && entry.name !== '__tests__') {
-                walk(path.join(directory, entry.name), files);
-            }
-            continue;
-        }
-        const fileName = path.join(directory, entry.name);
-        if (!entry.name.endsWith('.test.ts') &&
-            !entry.name.endsWith('.spec.ts') &&
-            (entry.name.endsWith('.html') || isTypeScriptFile(fileName))) {
-            files.push(fileName);
-        }
-    }
-}
-function isTypeScriptFile(fileName) {
-    return (fileName.endsWith('.ts') || fileName.endsWith('.tsx')) && !fileName.endsWith('.d.ts');
-}
-function collectPackages(workspaceRoot) {
-    const roots = [];
-    for (const groupName of ['packages', 'plugins']) {
-        const group = path.join(workspaceRoot, groupName);
-        if (!existsSync(group) || !statSync(group).isDirectory())
-            continue;
-        for (const entry of readdirSync(group, { withFileTypes: true })) {
-            if (!entry.isDirectory())
-                continue;
-            const direct = path.join(group, entry.name);
-            if (existsSync(path.join(direct, 'package.json'))) {
-                roots.push(direct);
-                continue;
-            }
-            for (const nested of readdirSync(direct, { withFileTypes: true })) {
-                if (nested.isDirectory() && existsSync(path.join(direct, nested.name, 'package.json'))) {
-                    roots.push(path.join(direct, nested.name));
-                }
-            }
-        }
-    }
-    return roots
-        .map((root) => {
-        const packageJson = readJsonFile(path.join(root, 'package.json'));
-        return {
-            name: typeof packageJson?.name === 'string'
-                ? packageJson.name
-                : manifestPath(root, workspaceRoot),
-            ...(typeof packageJson?.version === 'string' ? { version: packageJson.version } : {}),
-            path: manifestPath(root, workspaceRoot),
-            ...(typeof packageJson?.private === 'boolean' ? { private: packageJson.private } : {}),
-        };
-    })
-        .sort((left, right) => left.path.localeCompare(right.path));
-}
-function readTsConfig(tsconfigPath, projectRoot) {
-    const read = ts.readConfigFile(tsconfigPath, (fileName) => ts.sys.readFile(fileName));
-    if (read.error !== undefined)
-        throw new Error(formatTsDiagnostic(read.error));
-    return ts.parseJsonConfigFileContent(read.config, ts.sys, projectRoot, undefined, tsconfigPath);
-}
-function readJsonFile(fileName) {
-    try {
-        const value = JSON.parse(readFileSync(fileName, 'utf8'));
-        return typeof value === 'object' && value !== null && !Array.isArray(value)
-            ? value
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function findWorkspaceRoot(start) {
-    let current = path.resolve(start);
-    while (true) {
-        if (existsSync(path.join(current, 'pnpm-workspace.yaml')))
-            return current;
-        const parent = path.dirname(current);
-        if (parent === current)
-            return path.resolve(start);
-        current = parent;
-    }
-}
-function manifestPath(fileName, workspaceRoot) {
-    const relative = path.relative(workspaceRoot, fileName).replaceAll(path.sep, '/');
-    return relative === '' ? '.' : relative;
-}
-function toManifestRoute(route, workspaceRoot) {
-    return {
-        kind: route.kind,
-        path: route.path,
-        file: manifestPath(route.file, workspaceRoot),
-        layouts: route.layouts.map((fileName) => manifestPath(fileName, workspaceRoot)),
-        ...(route.error === undefined ? {} : { error: manifestPath(route.error, workspaceRoot) }),
-        hasGuard: route.hasGuard,
-        hasLoader: route.hasLoader,
-    };
-}
-function toManifestComponent(component, workspaceRoot) {
-    return {
-        kind: component.kind,
-        file: manifestPath(component.file, workspaceRoot),
-        ...(component.view === undefined ? {} : { view: manifestPath(component.view, workspaceRoot) }),
-        exports: component.exports,
-        props: component.props,
-        emits: component.emits,
-        exposed: component.exposed,
-        registeredComponents: component.registeredComponents,
-    };
-}
-function toManifestView(view, workspaceRoot) {
-    return {
-        file: manifestPath(view.file, workspaceRoot),
-        bindings: view.bindings,
-        events: view.events,
-        directives: view.directives,
-        components: view.components,
-        includes: view.includes
-            .map((request) => path.resolve(path.dirname(view.file), request))
-            .filter((fileName) => isPathInside(workspaceRoot, fileName))
-            .map((fileName) => manifestPath(fileName, workspaceRoot)),
-        refs: view.refs,
-        slots: view.slots,
-    };
-}
-function toManifestPermission(file, workspaceRoot) {
-    return {
-        file: manifestPath(file.file, workspaceRoot),
-        kinds: file.kinds,
-        symbols: file.symbols,
-    };
-}
-function toManifestDiagnostic(diagnostic, workspaceRoot) {
-    return {
-        code: diagnostic.code,
-        message: diagnostic.message,
-        severity: diagnostic.severity,
-        phase: diagnostic.phase,
-        ...(diagnostic.sourceId === undefined
-            ? {}
-            : { source: manifestPath(diagnostic.sourceId, workspaceRoot) }),
-        ...(diagnostic.start === undefined ? {} : { start: diagnostic.start }),
-        ...(diagnostic.end === undefined ? {} : { end: diagnostic.end }),
-    };
-}
-function formatTsDiagnostic(diagnostic) {
-    return ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-}
-function isPathInside(root, fileName) {
-    const relative = path.relative(root, fileName);
-    return relative === '' || (!relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
-}

package/dist/logo/cli-logo.d.ts

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/cli
- */
-export declare function renderCliLogo(): string;

package/dist/logo/cli-logo.js

@@ -1,16 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/cli
- */
-import chalk from 'chalk';
-const BRAND_COLOR = '#2DD4BF';
-const LOGO_MARK = ['╭──────╮', '│ vobs │', '╰──────╯'];
-const PRODUCT_NAME = 'vobs';
-export function renderCliLogo() {
-    const brand = chalk.hex(BRAND_COLOR);
-    return [
-        brand(LOGO_MARK[0]),
-        `${brand(LOGO_MARK[1])} ${brand.bold(PRODUCT_NAME)}`,
-        brand(LOGO_MARK[2]),
-    ].join('\n');
-}

package/dist/scaffold.d.ts

@@ -1,23 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/cli
- */
-export type ScaffoldTemplate = 'app' | 'app-di' | 'enterprise' | 'lib' | 'lib-di';
-export interface ScaffoldOptions {
-    readonly template?: ScaffoldTemplate;
-    readonly withDi?: boolean;
-    readonly force?: boolean;
-}
-export interface ScaffoldResult {
-    readonly name: string;
-    readonly targetDir: string;
-    readonly template: ScaffoldTemplate;
-}
-export interface TemplateFile {
-    readonly path: string;
-    readonly content: string;
-}
-export declare function createScaffold(type: string | undefined, name: string | undefined, options?: ScaffoldOptions, cwd?: string): ScaffoldResult;
-export declare function resolveScaffoldTemplate(type: string | undefined, options?: ScaffoldOptions): ScaffoldTemplate;
-export declare function isScaffoldTemplate(value: string): value is ScaffoldTemplate;
-export declare function scaffoldSuccessText(result: ScaffoldResult): string;