@wp-typia/project-tools 0.11.1

package/dist/runtime/object-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generic record type used for JSON-like plain-object inspection.
+ */
+export type UnknownRecord = Record<string, unknown>;
+/**
+ * Check whether a value is a plain object record.
+ *
+ * @param value Runtime value to inspect.
+ * @returns `true` when the value is a non-null plain object with an
+ * `Object.prototype` or `null` prototype.
+ */
+export declare function isPlainObject(value: unknown): value is UnknownRecord;

package/dist/runtime/object-utils.js

@@ -0,0 +1,14 @@
+/**
+ * Check whether a value is a plain object record.
+ *
+ * @param value Runtime value to inspect.
+ * @returns `true` when the value is a non-null plain object with an
+ * `Object.prototype` or `null` prototype.
+ */
+export function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/runtime/package-managers.d.ts

@@ -0,0 +1,28 @@
+export type PackageManagerId = "bun" | "npm" | "pnpm" | "yarn";
+export interface PackageManagerDefinition {
+    id: PackageManagerId;
+    label: string;
+    packageManagerField: string;
+    installCommand: string;
+    frozenInstallCommand: string;
+}
+export declare const PACKAGE_MANAGER_IDS: PackageManagerId[];
+export declare const PACKAGE_MANAGERS: Readonly<Record<PackageManagerId, PackageManagerDefinition>>;
+export declare function getPackageManager(id: string): PackageManagerDefinition;
+export declare function getPackageManagerSelectOptions(): Array<{
+    label: string;
+    value: PackageManagerId;
+    hint: string;
+}>;
+export declare function formatRunScript(packageManagerId: PackageManagerId, scriptName: string, extraArgs?: string): string;
+export declare function formatInstallCommand(packageManagerId: PackageManagerId): string;
+/**
+ * Format a package-manager-specific one-off package execution command.
+ *
+ * @param packageManagerId Package manager identifier.
+ * @param packageName Executable package name.
+ * @param extraArgs Optional extra CLI arguments appended after the package name.
+ * @returns Command string suitable for shell execution.
+ */
+export declare function formatPackageExecCommand(packageManagerId: PackageManagerId, packageName: string, extraArgs?: string): string;
+export declare function transformPackageManagerText(content: string, packageManagerId: PackageManagerId): string;

package/dist/runtime/package-managers.js

@@ -0,0 +1,156 @@
+const PACKAGE_MANAGER_DATA = [
+    {
+        id: "bun",
+        label: "Bun",
+        packageManagerField: "bun@1.3.10",
+        installCommand: "bun install",
+        frozenInstallCommand: "bun install --frozen-lockfile",
+    },
+    {
+        id: "npm",
+        label: "npm",
+        packageManagerField: "npm@11.6.1",
+        installCommand: "npm install",
+        frozenInstallCommand: "npm ci",
+    },
+    {
+        id: "pnpm",
+        label: "pnpm",
+        packageManagerField: "pnpm@8.3.1",
+        installCommand: "pnpm install",
+        frozenInstallCommand: "pnpm install --frozen-lockfile",
+    },
+    {
+        id: "yarn",
+        label: "Yarn",
+        packageManagerField: "yarn@3.2.4",
+        installCommand: "yarn install",
+        frozenInstallCommand: "yarn install --frozen-lockfile",
+    },
+];
+export const PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_DATA.map((manager) => manager.id);
+export const PACKAGE_MANAGERS = Object.freeze(Object.fromEntries(PACKAGE_MANAGER_DATA.map((manager) => [manager.id, manager])));
+const DEV_INSTALL_FLAGS = {
+    bun: "add -d",
+    npm: "install --save-dev",
+    pnpm: "add -D",
+    yarn: "add -D",
+};
+const STOP_CHARS = new Set(["\n", "\r", "`", "\"", "'", ")", "]", "}", "!", ",", "."]);
+export function getPackageManager(id) {
+    const manager = PACKAGE_MANAGERS[id];
+    if (!manager) {
+        throw new Error(`Unknown package manager "${id}". Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}`);
+    }
+    return manager;
+}
+export function getPackageManagerSelectOptions() {
+    return PACKAGE_MANAGER_DATA.map((manager) => ({
+        label: manager.label,
+        value: manager.id,
+        hint: manager.installCommand,
+    }));
+}
+export function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
+    const args = extraArgs.trim();
+    if (packageManagerId === "bun") {
+        return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
+    }
+    if (packageManagerId === "npm") {
+        return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
+    }
+    if (packageManagerId === "pnpm") {
+        return args ? `pnpm run ${scriptName} ${args}` : `pnpm run ${scriptName}`;
+    }
+    return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
+}
+export function formatInstallCommand(packageManagerId) {
+    return getPackageManager(packageManagerId).installCommand;
+}
+/**
+ * Format a package-manager-specific one-off package execution command.
+ *
+ * @param packageManagerId Package manager identifier.
+ * @param packageName Executable package name.
+ * @param extraArgs Optional extra CLI arguments appended after the package name.
+ * @returns Command string suitable for shell execution.
+ */
+export function formatPackageExecCommand(packageManagerId, packageName, extraArgs = "") {
+    const args = extraArgs.trim();
+    if (packageManagerId === "bun") {
+        return args ? `bunx ${packageName} ${args}` : `bunx ${packageName}`;
+    }
+    if (packageManagerId === "npm") {
+        return args ? `npx --yes ${packageName} ${args}` : `npx --yes ${packageName}`;
+    }
+    if (packageManagerId === "pnpm") {
+        return args ? `pnpm dlx ${packageName} ${args}` : `pnpm dlx ${packageName}`;
+    }
+    return args ? `yarn dlx ${packageName} ${args}` : `yarn dlx ${packageName}`;
+}
+function consumeCommandArguments(content, startIndex) {
+    let cursor = startIndex;
+    let args = "";
+    while (cursor < content.length) {
+        const current = content[cursor];
+        if (STOP_CHARS.has(current) ||
+            content.startsWith("&&", cursor) ||
+            content.startsWith("||", cursor) ||
+            current === ";") {
+            break;
+        }
+        args += current;
+        cursor += 1;
+    }
+    return {
+        args: args.trim(),
+        cursor,
+    };
+}
+function replaceBunRunCommands(content, packageManagerId) {
+    const marker = "bun run ";
+    let result = "";
+    let cursor = 0;
+    while (cursor < content.length) {
+        const index = content.indexOf(marker, cursor);
+        if (index === -1) {
+            result += content.slice(cursor);
+            break;
+        }
+        if (index > 0 && /[A-Za-z0-9_-]/.test(content[index - 1])) {
+            result += content.slice(cursor, index + marker.length);
+            cursor = index + marker.length;
+            continue;
+        }
+        result += content.slice(cursor, index);
+        const scriptNameStart = index + marker.length;
+        const scriptNameMatch = /^[A-Za-z0-9:_-]+/.exec(content.slice(scriptNameStart));
+        if (!scriptNameMatch) {
+            result += marker;
+            cursor = scriptNameStart;
+            continue;
+        }
+        const scriptName = scriptNameMatch[0];
+        const argsStart = scriptNameStart + scriptName.length;
+        const { args, cursor: nextCursor } = consumeCommandArguments(content, argsStart);
+        result += formatRunScript(packageManagerId, scriptName, args);
+        cursor = nextCursor;
+    }
+    return result;
+}
+function replaceDevDependencyInstalls(content, packageManagerId) {
+    return content.replace(/\bbun add -d ([^\s&|;`"'()]+)\b/g, (_, packageName) => {
+        if (packageManagerId === "bun") {
+            return `bun add -d ${packageName}`;
+        }
+        return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packageName}`;
+    });
+}
+export function transformPackageManagerText(content, packageManagerId) {
+    const manager = getPackageManager(packageManagerId);
+    return replaceDevDependencyInstalls(replaceBunRunCommands(content
+        .replace(/\bbun install --frozen-lockfile\b/g, manager.frozenInstallCommand)
+        .replace(/\bbun install\b/g, manager.installCommand), packageManagerId), packageManagerId)
+        .replace(/\s*&&\s*/g, " && ")
+        .replace(/\s*\|\|\s*/g, " || ");
+}

package/dist/runtime/package-versions.d.ts

@@ -0,0 +1,10 @@
+interface PackageVersions {
+    apiClientPackageVersion: string;
+    blockRuntimePackageVersion: string;
+    blockTypesPackageVersion: string;
+    projectToolsPackageVersion: string;
+    restPackageVersion: string;
+    wpTypiaPackageVersion: string;
+}
+export declare function getPackageVersions(): PackageVersions;
+export {};

package/dist/runtime/package-versions.js

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
+const require = createRequire(import.meta.url);
+const DEFAULT_VERSION_RANGE = "^0.0.0";
+let cachedPackageVersions = null;
+function getErrorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+}
+function normalizeVersionRange(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return DEFAULT_VERSION_RANGE;
+    }
+    return /^[~^<>=]/.test(trimmed) ? trimmed : `^${trimmed}`;
+}
+function readPackageManifest(packageJsonPath) {
+    try {
+        return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    }
+    catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function resolveInstalledPackageManifest(packageName) {
+    try {
+        return readPackageManifest(require.resolve(`${packageName}/package.json`));
+    }
+    catch (error) {
+        if (getErrorCode(error) === "MODULE_NOT_FOUND") {
+            return null;
+        }
+        throw error;
+    }
+}
+export function getPackageVersions() {
+    if (cachedPackageVersions) {
+        return cachedPackageVersions;
+    }
+    const createManifest = readPackageManifest(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json")) ??
+        resolveInstalledPackageManifest("@wp-typia/project-tools") ??
+        {};
+    const blockRuntimeManifest = readPackageManifest(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia-block-runtime", "package.json")) ??
+        resolveInstalledPackageManifest("@wp-typia/block-runtime") ??
+        {};
+    const wpTypiaManifest = readPackageManifest(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia", "package.json")) ??
+        resolveInstalledPackageManifest("wp-typia") ??
+        {};
+    cachedPackageVersions = {
+        apiClientPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/api-client"] ??
+            resolveInstalledPackageManifest("@wp-typia/api-client")?.version),
+        blockRuntimePackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/block-runtime"] ??
+            blockRuntimeManifest.version),
+        blockTypesPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/block-types"] ??
+            resolveInstalledPackageManifest("@wp-typia/block-types")?.version),
+        projectToolsPackageVersion: normalizeVersionRange(createManifest.version),
+        restPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/rest"] ??
+            resolveInstalledPackageManifest("@wp-typia/rest")?.version),
+        wpTypiaPackageVersion: normalizeVersionRange(wpTypiaManifest.version),
+    };
+    return cachedPackageVersions;
+}

package/dist/runtime/scaffold-onboarding.d.ts

@@ -0,0 +1,32 @@
+import type { PackageManagerId } from "./package-managers.js";
+interface SyncOnboardingOptions {
+    compoundPersistenceEnabled?: boolean;
+}
+interface PhpRestExtensionOptions extends SyncOnboardingOptions {
+    slug: string;
+}
+/**
+ * Returns the optional sync script names to suggest for a template.
+ */
+export declare function getOptionalSyncScriptNames(templateId: string, options?: SyncOnboardingOptions): string[];
+/**
+ * Formats optional onboarding sync commands for the selected package manager.
+ */
+export declare function getOptionalOnboardingSteps(packageManager: PackageManagerId, templateId: string, options?: SyncOnboardingOptions): string[];
+/**
+ * Returns the onboarding note explaining when manual sync is optional.
+ */
+export declare function getOptionalOnboardingNote(packageManager: PackageManagerId, templateId?: string): string;
+/**
+ * Returns source-of-truth guidance for generated artifacts by template mode.
+ */
+export declare function getTemplateSourceOfTruthNote(templateId: string, { compoundPersistenceEnabled }?: SyncOnboardingOptions): string;
+/**
+ * Returns the generated-project extension workflow for compound child blocks.
+ */
+export declare function getCompoundExtensionWorkflowSection(packageManager: PackageManagerId, templateId: string): string | null;
+/**
+ * Returns scaffold-local guidance for the main PHP REST customization points.
+ */
+export declare function getPhpRestExtensionPointsSection(templateId: string, { compoundPersistenceEnabled, slug }: PhpRestExtensionOptions): string | null;
+export {};

package/dist/runtime/scaffold-onboarding.js

@@ -0,0 +1,99 @@
+import { formatRunScript } from "./package-managers.js";
+import { getPrimaryDevelopmentScript } from "./local-dev-presets.js";
+function templateHasPersistenceSync(templateId, { compoundPersistenceEnabled = false } = {}) {
+    return templateId === "persistence" || (templateId === "compound" && compoundPersistenceEnabled);
+}
+/**
+ * Returns the optional sync script names to suggest for a template.
+ */
+export function getOptionalSyncScriptNames(templateId, options = {}) {
+    return templateHasPersistenceSync(templateId, options)
+        ? ["sync-types", "sync-rest"]
+        : ["sync-types"];
+}
+/**
+ * Formats optional onboarding sync commands for the selected package manager.
+ */
+export function getOptionalOnboardingSteps(packageManager, templateId, options = {}) {
+    return getOptionalSyncScriptNames(templateId, options).map((scriptName) => formatRunScript(packageManager, scriptName));
+}
+/**
+ * Returns the onboarding note explaining when manual sync is optional.
+ */
+export function getOptionalOnboardingNote(packageManager, templateId = "basic") {
+    const developmentScript = getPrimaryDevelopmentScript(templateId);
+    const failOnLossySyncCommand = formatRunScript(packageManager, "sync-types", "--fail-on-lossy");
+    const syncTypesCommand = formatRunScript(packageManager, "sync-types");
+    const typecheckCommand = formatRunScript(packageManager, "typecheck");
+    const strictSyncCommand = formatRunScript(packageManager, "sync-types", "--strict --report json");
+    return `${formatRunScript(packageManager, developmentScript)} ${developmentScript === "dev"
+        ? "watches the relevant sync scripts during local development."
+        : "remains the primary local entry point."} ${formatRunScript(packageManager, "start")} still runs one-shot syncs before starting, while ${formatRunScript(packageManager, "build")} and ${typecheckCommand} verify that generated metadata/schema artifacts are already current and fail if they are stale. Run the sync scripts manually when you want to refresh generated artifacts before build, typecheck, or commit. ${syncTypesCommand} stays warn-only by default; use \`${failOnLossySyncCommand}\` to fail only on lossy WordPress projections, or \`${strictSyncCommand}\` for a CI-friendly JSON report that fails on all warnings. They do not create migration history.`;
+}
+/**
+ * Returns source-of-truth guidance for generated artifacts by template mode.
+ */
+export function getTemplateSourceOfTruthNote(templateId, { compoundPersistenceEnabled = false } = {}) {
+    if (templateId === "compound") {
+        const compoundBase = "`src/blocks/*/types.ts` files remain the source of truth for each block's `block.json`, `typia.manifest.json`, and `typia-validator.php`. Fresh scaffolds include starter `typia.manifest.json` files so editor imports resolve before the first sync.";
+        if (compoundPersistenceEnabled) {
+            return `${compoundBase} For persistence-enabled parents, \`src/blocks/*/api-types.ts\` files remain the source of truth for \`src/blocks/*/api-schemas/*\` when you run \`sync-rest\`.`;
+        }
+        return compoundBase;
+    }
+    if (templateId === "persistence") {
+        return "`src/types.ts` remains the source of truth for `block.json`, `typia.manifest.json`, and `typia-validator.php`. Fresh scaffolds include a starter `typia.manifest.json` so editor imports resolve before the first sync. `src/api-types.ts` remains the source of truth for `src/api-schemas/*` when you run `sync-rest`. This scaffold is intentionally server-rendered: `src/render.php` is the canonical frontend entry, and `src/save.tsx` returns `null` so PHP can inject post context, storage-backed state, and write-policy bootstrap data before hydration.";
+    }
+    return "`src/types.ts` remains the source of truth for `block.json`, `typia.manifest.json`, and `typia-validator.php`. Fresh scaffolds include a starter `typia.manifest.json` so editor imports resolve before the first sync. The basic scaffold stays static by design: it does not generate `render.php`, `src/save.tsx` always returns stable markup, and the generated webpack config keeps the current `@wordpress/scripts` CommonJS baseline.";
+}
+/**
+ * Returns the generated-project extension workflow for compound child blocks.
+ */
+export function getCompoundExtensionWorkflowSection(packageManager, templateId) {
+    if (templateId !== "compound") {
+        return null;
+    }
+    return `## Compound Extension Workflow
+
+\`\`\`bash
+${formatRunScript(packageManager, "add-child", '--slug faq-item --title "FAQ Item"')}
+\`\`\`
+
+This scaffolds a new hidden child block type, updates \`scripts/block-config.ts\` and \`src/blocks/*/children.ts\`, and leaves the default seeded child template unchanged.`;
+}
+function formatPhpRestExtensionPointsSection({ apiTypesPath, extraNote, mainPhpPath, mainPhpScope, }) {
+    const schemaJsonGlob = apiTypesPath.replace(/api-types\.ts$/u, "api-schemas/*.schema.json");
+    const perContractOpenApiGlob = apiTypesPath.replace(/api-types\.ts$/u, "api-schemas/*.openapi.json");
+    const aggregateOpenApiPath = apiTypesPath.replace(/api-types\.ts$/u, "api.openapi.json");
+    const lines = [
+        `- Edit \`${mainPhpPath}\` when you need to ${mainPhpScope}.`,
+        "- Edit `inc/rest-auth.php` or `inc/rest-public.php` when you need to customize write permissions or token/request-id/nonce checks for the selected policy.",
+        `- Keep \`${apiTypesPath}\` as the source of truth for request and response contracts, then regenerate \`${schemaJsonGlob}\`, per-contract \`${perContractOpenApiGlob}\`, and \`${aggregateOpenApiPath}\` with \`sync-rest\`.`,
+        "- Avoid hand-editing generated schema and OpenAPI artifacts unless you are debugging generated output; they are meant to be regenerated from TypeScript contracts.",
+    ];
+    if (typeof extraNote === "string" && extraNote.length > 0) {
+        lines.push(`- ${extraNote}`);
+    }
+    return `## PHP REST Extension Points\n\n${lines.join("\n")}`;
+}
+/**
+ * Returns scaffold-local guidance for the main PHP REST customization points.
+ */
+export function getPhpRestExtensionPointsSection(templateId, { compoundPersistenceEnabled = false, slug }) {
+    if (templateId === "persistence") {
+        return formatPhpRestExtensionPointsSection({
+            apiTypesPath: "src/api-types.ts",
+            mainPhpPath: `${slug}.php`,
+            mainPhpScope: "change storage helpers, route handlers, response shaping, or route registration",
+        });
+    }
+    if (templateId === "compound" && compoundPersistenceEnabled) {
+        return formatPhpRestExtensionPointsSection({
+            apiTypesPath: `src/blocks/${slug}/api-types.ts`,
+            extraNote: "The hidden child block does not own REST routes or storage.",
+            mainPhpPath: `${slug}.php`,
+            mainPhpScope: "change parent-block storage helpers, route handlers, response shaping, or route registration",
+        });
+    }
+    return null;
+}

package/dist/runtime/scaffold.d.ts

@@ -0,0 +1,146 @@
+import type { PackageManagerId } from "./package-managers.js";
+import type { BuiltInTemplateId } from "./template-registry.js";
+/**
+ * User-facing scaffold answers before template rendering.
+ *
+ * `namespace`, `textDomain`, and `phpPrefix` are normalized before use so
+ * callers can pass human-entered values while generated output stays
+ * predictable.
+ */
+export interface ScaffoldAnswers {
+    author: string;
+    dataStorageMode?: DataStorageMode;
+    description: string;
+    /** Block namespace used in generated block names such as `namespace/slug`. */
+    namespace: string;
+    persistencePolicy?: PersistencePolicy;
+    /** Snake_case PHP symbol prefix used for generated functions, constants, and keys. */
+    phpPrefix?: string;
+    slug: string;
+    /** Kebab-case WordPress text domain used in block metadata and i18n strings. */
+    textDomain?: string;
+    title: string;
+}
+export declare const DATA_STORAGE_MODES: readonly ["post-meta", "custom-table"];
+export type DataStorageMode = (typeof DATA_STORAGE_MODES)[number];
+export declare const PERSISTENCE_POLICIES: readonly ["authenticated", "public"];
+export type PersistencePolicy = (typeof PERSISTENCE_POLICIES)[number];
+/**
+ * Normalized template variables shared by built-in and remote scaffold flows.
+ */
+export interface ScaffoldTemplateVariables extends Record<string, string> {
+    apiClientPackageVersion: string;
+    author: string;
+    blockRuntimePackageVersion: string;
+    blockMetadataVersion: string;
+    blockTypesPackageVersion: string;
+    category: string;
+    icon: string;
+    compoundChildTitle: string;
+    compoundChildCategory: string;
+    compoundChildCssClassName: string;
+    compoundChildIcon: string;
+    compoundChildTitleJson: string;
+    compoundPersistenceEnabled: "false" | "true";
+    projectToolsPackageVersion: string;
+    cssClassName: string;
+    dashCase: string;
+    dataStorageMode: DataStorageMode;
+    description: string;
+    frontendCssClassName: string;
+    keyword: string;
+    namespace: string;
+    needsMigration: string;
+    pascalCase: string;
+    phpPrefix: string;
+    phpPrefixUpper: string;
+    isAuthenticatedPersistencePolicy: "false" | "true";
+    isPublicPersistencePolicy: "false" | "true";
+    publicWriteRequestIdDeclaration: string;
+    restPackageVersion: string;
+    restWriteAuthIntent: "authenticated" | "public-write-protected";
+    restWriteAuthMechanism: "public-signed-token" | "rest-nonce";
+    restWriteAuthMode: "authenticated-rest-nonce" | "public-signed-token";
+    slug: string;
+    slugCamelCase: string;
+    slugKebabCase: string;
+    slugSnakeCase: string;
+    textDomain: string;
+    textdomain: string;
+    title: string;
+    titleJson: string;
+    titleCase: string;
+    persistencePolicy: PersistencePolicy;
+}
+interface ResolveTemplateOptions {
+    isInteractive?: boolean;
+    selectTemplate?: () => Promise<BuiltInTemplateId>;
+    templateId?: string;
+    yes?: boolean;
+}
+interface ResolvePackageManagerOptions {
+    isInteractive?: boolean;
+    packageManager?: string;
+    selectPackageManager?: () => Promise<PackageManagerId>;
+    yes?: boolean;
+}
+interface CollectScaffoldAnswersOptions {
+    dataStorageMode?: DataStorageMode;
+    namespace?: string;
+    phpPrefix?: string;
+    projectName: string;
+    promptText?: (message: string, defaultValue: string, validate?: (value: string) => true | string) => Promise<string>;
+    persistencePolicy?: PersistencePolicy;
+    textDomain?: string;
+    templateId: string;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+    yes?: boolean;
+}
+interface InstallDependenciesOptions {
+    packageManager: PackageManagerId;
+    projectDir: string;
+}
+interface ScaffoldProjectOptions {
+    allowExistingDir?: boolean;
+    answers: ScaffoldAnswers;
+    cwd?: string;
+    dataStorageMode?: DataStorageMode;
+    installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
+    noInstall?: boolean;
+    packageManager: PackageManagerId;
+    persistencePolicy?: PersistencePolicy;
+    projectDir: string;
+    templateId: string;
+    variant?: string;
+    withMigrationUi?: boolean;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+}
+export interface ScaffoldProjectResult {
+    packageManager: PackageManagerId;
+    projectDir: string;
+    selectedVariant: string | null;
+    templateId: string;
+    variables: ScaffoldTemplateVariables;
+    warnings: string[];
+}
+/**
+ * Builds the generated WordPress wrapper CSS class for a scaffolded block.
+ *
+ * Returns `wp-block-{namespace}-{slug}` when a non-empty namespace is present,
+ * or `wp-block-{slug}` when the namespace is empty or undefined. Both inputs
+ * are normalized and validated with the same scaffold identifier rules used for
+ * block names.
+ */
+export declare function buildBlockCssClassName(namespace: string | undefined, slug: string): string;
+export declare function isDataStorageMode(value: string): value is DataStorageMode;
+export declare function isPersistencePolicy(value: string): value is PersistencePolicy;
+export declare function detectAuthor(): string;
+export declare function getDefaultAnswers(projectName: string, templateId: string): ScaffoldAnswers;
+export declare function resolveTemplateId({ templateId, yes, isInteractive, selectTemplate, }: ResolveTemplateOptions): Promise<string>;
+export declare function resolvePackageManagerId({ packageManager, yes, isInteractive, selectPackageManager, }: ResolvePackageManagerOptions): Promise<PackageManagerId>;
+export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;
+export declare function getTemplateVariables(templateId: string, answers: ScaffoldAnswers): ScaffoldTemplateVariables;
+export declare function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, cwd, allowExistingDir, noInstall, installDependencies, variant, withMigrationUi, withTestPreset, withWpEnv, }: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;
+export {};