@wp-typia/project-tools 0.22.10 → 0.23.1

package/dist/runtime/cli-add-workspace-admin-view-types.d.ts

@@ -22,6 +22,27 @@ export interface AdminViewCoreDataSource {
 }
 export type AdminViewSource = AdminViewCoreDataSource | AdminViewRestResourceSource;
 export type AdminViewRestResource = WorkspaceRestResourceInventoryEntry;
+/**
+ * Manual REST resource metadata required to scaffold a typed admin settings
+ * screen. The type narrows a workspace REST inventory entry to manual
+ * contracts that expose request body, query, and response type names.
+ */
+export type AdminViewManualSettingsRestResource = AdminViewRestResource & {
+    bodyTypeName: string;
+    mode: 'manual';
+    queryTypeName: string;
+    responseTypeName: string;
+};
 export declare function isAdminViewCoreDataSource(source: AdminViewSource | undefined): source is AdminViewCoreDataSource;
 export declare function isAdminViewRestResourceSource(source: AdminViewSource | undefined): source is AdminViewRestResourceSource;
+/**
+ * Return whether a REST inventory entry has the manual contract shape required
+ * by generated settings screens.
+ */
+export declare function isAdminViewManualSettingsRestResource(restResource: AdminViewRestResource | undefined): restResource is AdminViewManualSettingsRestResource;
+/**
+ * Return whether a REST inventory entry uses route regex groups that a
+ * generated singleton settings screen cannot satisfy with path input.
+ */
+export declare function hasAdminViewManualSettingsRouteParameters(restResource: AdminViewRestResource | undefined): boolean;
 export declare function formatAdminViewSourceLocator(source: AdminViewSource): string;

package/dist/runtime/cli-add-workspace-admin-view-types.js

@@ -12,12 +12,34 @@ export const ADMIN_VIEWS_ASSET = 'build/admin-views/index.asset.php';
 export const ADMIN_VIEWS_STYLE = 'build/admin-views/style-index.css';
 export const ADMIN_VIEWS_STYLE_RTL = 'build/admin-views/style-index-rtl.css';
 export const ADMIN_VIEWS_PHP_GLOB = '/inc/admin-views/*.php';
+const ADMIN_VIEW_MANUAL_REST_ROUTE_PARAMETER_PATTERN = /(?:^|[^\\])\(/u;
 export function isAdminViewCoreDataSource(source) {
     return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
 }
 export function isAdminViewRestResourceSource(source) {
     return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
 }
+/**
+ * Return whether a REST inventory entry has the manual contract shape required
+ * by generated settings screens.
+ */
+export function isAdminViewManualSettingsRestResource(restResource) {
+    return (restResource?.mode === 'manual' &&
+        typeof restResource.bodyTypeName === 'string' &&
+        restResource.bodyTypeName.trim().length > 0 &&
+        typeof restResource.queryTypeName === 'string' &&
+        restResource.queryTypeName.trim().length > 0 &&
+        typeof restResource.responseTypeName === 'string' &&
+        restResource.responseTypeName.trim().length > 0);
+}
+/**
+ * Return whether a REST inventory entry uses route regex groups that a
+ * generated singleton settings screen cannot satisfy with path input.
+ */
+export function hasAdminViewManualSettingsRouteParameters(restResource) {
+    return [restResource?.pathPattern, restResource?.routePattern].some((pattern) => typeof pattern === 'string' &&
+        ADMIN_VIEW_MANUAL_REST_ROUTE_PARAMETER_PATTERN.test(pattern));
+}
 export function formatAdminViewSourceLocator(source) {
     if (isAdminViewCoreDataSource(source)) {
         return `${source.kind}:${source.entityKind}/${source.entityName}`;

package/dist/runtime/cli-add-workspace-ai-anchors.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { getPackageVersions } from "./package-versions.js";
 import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
 import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
+import { readJsonFile } from "./json-utils.js";
 import { hasPhpFunctionDefinition } from "./php-utils.js";
 const AI_FEATURE_SERVER_GLOB = "/inc/ai-features/*.php";
 /**
@@ -43,7 +44,9 @@ function ${registerFunctionName}() {
  */
 export async function ensureAiFeaturePackageScripts(workspace) {
     const packageJsonPath = path.join(workspace.projectDir, "package.json");
-    const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+    const packageJson = await readJsonFile(packageJsonPath, {
+        context: "workspace package manifest",
+    });
     const nextScripts = {
         ...(packageJson.scripts ?? {}),
         "sync-ai": packageJson.scripts?.["sync-ai"] ?? "tsx scripts/sync-ai-features.ts",
@@ -126,35 +129,131 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
     assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath);
     return nextSource.replace(anchor, replacement);
 }
+function replaceBlockConfigImportForAiFeatures(nextSource, syncRestScriptPath) {
+    const importPatterns = [
+        /^import\s*\{\n(?:\t[^\n]*\n)+\} from ["']\.\/block-config["'];?$/mu,
+        /^import\s*\{[^\n]*\}\s*from\s*["']\.\/block-config["'];?$/mu,
+    ];
+    const importMatch = importPatterns.map((pattern) => pattern.exec(nextSource)).find(Boolean) ??
+        null;
+    if (!importMatch) {
+        throw new Error([
+            `ensureAiFeatureSyncRestAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+            "Missing expected workspace inventory import anchor in scripts/sync-rest-contracts.ts.",
+            "Restore the generated template or add the AI feature wiring manually before retrying.",
+        ].join(" "));
+    }
+    const importSource = importMatch[0];
+    if (importSource.includes("AI_FEATURES") &&
+        importSource.includes("WorkspaceAiFeatureConfig")) {
+        return nextSource;
+    }
+    const hasContracts = importSource.includes("CONTRACTS");
+    const hasContractConfig = importSource.includes("WorkspaceContractConfig");
+    const hasPostMeta = importSource.includes("POST_META");
+    const hasPostMetaConfig = importSource.includes("WorkspacePostMetaConfig");
+    const replacement = [
+        "import {",
+        "\tAI_FEATURES,",
+        "\tBLOCKS,",
+        ...(hasContracts ? ["\tCONTRACTS,"] : []),
+        ...(hasPostMeta ? ["\tPOST_META,"] : []),
+        "\tREST_RESOURCES,",
+        "\ttype WorkspaceAiFeatureConfig,",
+        "\ttype WorkspaceBlockConfig,",
+        ...(hasContractConfig ? ["\ttype WorkspaceContractConfig,"] : []),
+        ...(hasPostMetaConfig ? ["\ttype WorkspacePostMetaConfig,"] : []),
+        "\ttype WorkspaceRestResourceConfig,",
+        "} from './block-config';",
+    ].join("\n");
+    return nextSource.replace(importSource, replacement);
+}
+function replaceAiFeatureSyncSummaryCopy(nextSource, syncRestScriptPath) {
+    const standaloneSummary = "workspace blocks, standalone contracts, and plugin-level resources";
+    const standaloneAiSummary = "workspace blocks, standalone contracts, plugin-level resources, and AI features";
+    const standalonePostMetaSummary = "workspace blocks, standalone contracts, post meta contracts, and plugin-level resources";
+    const standalonePostMetaAiSummary = "workspace blocks, standalone contracts, post meta contracts, plugin-level resources, and AI features";
+    const postMetaSummary = "workspace blocks, post meta contracts, and plugin-level resources";
+    const postMetaAiSummary = "workspace blocks, post meta contracts, plugin-level resources, and AI features";
+    const restResourceSummary = "workspace blocks and plugin-level resources";
+    const restResourceAiSummary = "workspace blocks, plugin-level resources, and AI features";
+    if (nextSource.includes(standalonePostMetaSummary)) {
+        return nextSource
+            .split(standalonePostMetaSummary)
+            .join(standalonePostMetaAiSummary);
+    }
+    if (nextSource.includes(standaloneSummary)) {
+        return nextSource.split(standaloneSummary).join(standaloneAiSummary);
+    }
+    if (nextSource.includes(postMetaSummary)) {
+        return nextSource.split(postMetaSummary).join(postMetaAiSummary);
+    }
+    if (nextSource.includes(restResourceSummary)) {
+        return nextSource.split(restResourceSummary).join(restResourceAiSummary);
+    }
+    if (nextSource.includes(standaloneAiSummary) ||
+        nextSource.includes(standalonePostMetaAiSummary) ||
+        nextSource.includes(postMetaAiSummary) ||
+        nextSource.includes(restResourceAiSummary)) {
+        return nextSource;
+    }
+    throw new Error([
+        `ensureAiFeatureSyncRestAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+        "Missing expected sync summary copy anchor in scripts/sync-rest-contracts.ts.",
+        "Restore the generated template or add the AI feature wiring manually before retrying.",
+    ].join(" "));
+}
+function formatNoResourcesSubject(subjects) {
+    if (subjects.length <= 2) {
+        return subjects.join(" or ");
+    }
+    const lastSubject = subjects[subjects.length - 1];
+    return `${subjects.slice(0, -1).join(", ")}, or ${lastSubject}`;
+}
+function buildAiFeatureNoResourcesGuard({ hasPostMeta, hasStandaloneContracts, }) {
+    const condition = ["restBlocks.length === 0"];
+    if (hasStandaloneContracts) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("standaloneContracts.length === 0");
+    }
+    if (hasPostMeta) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("postMetaContracts.length === 0");
+    }
+    condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+    condition.push("restResources.length === 0 &&");
+    condition.push("aiFeatures.length === 0");
+    const noResourcesSubject = formatNoResourcesSubject([
+        "REST-enabled workspace blocks",
+        ...(hasStandaloneContracts ? ["standalone contracts"] : []),
+        ...(hasPostMeta ? ["post meta contracts"] : []),
+        "plugin-level REST resources",
+        "AI features",
+    ]);
+    return [
+        "if (",
+        ...condition.map((line) => `\t\t${line}`),
+        "\t) {",
+        "\t\tconsole.log(",
+        "\t\t\toptions.check",
+        `\t\t\t\t? 'ℹ️ No ${noResourcesSubject} are registered yet. \`sync-rest --check\` is already clean.'`,
+        `\t\t\t\t: 'ℹ️ No ${noResourcesSubject} are registered yet.'`,
+        "\t\t);",
+        "\t\treturn;",
+        "\t}",
+    ].join("\n");
+}
+const NO_RESOURCES_GUARD_PATTERN = /if \(\s*restBlocks\.length === 0(?:\s*&&\s*standaloneContracts\.length === 0)?(?:\s*&&\s*postMetaContracts\.length === 0)?\s*&&\s*restResources\.length === 0(?:\s*&&\s*aiFeatures\.length === 0)?\s*\) \{[\s\S]*?\n\t\treturn;\n\t\}/u;
 /**
  * Patch `scripts/sync-rest-contracts.ts` after sync-project wiring so AI feature REST artifacts join the split sync flow.
  */
 export async function ensureAiFeatureSyncRestAnchors(workspace) {
     const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
     await patchFile(syncRestScriptPath, (source) => {
-        let nextSource = source;
-        const importAnchor = [
-            "import {",
-            "\tBLOCKS,",
-            "\tREST_RESOURCES,",
-            "\ttype WorkspaceBlockConfig,",
-            "\ttype WorkspaceRestResourceConfig,",
-            "} from './block-config';",
-        ].join("\n");
+        let nextSource = replaceBlockConfigImportForAiFeatures(source, syncRestScriptPath);
         const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
         const restResourcesAnchor = "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );";
-        const noResourcesPattern = /if \( restBlocks.length === 0 && restResources.length === 0 \) \{[\s\S]*?\n\t\treturn;\n\t\}/u;
         const consoleLogPattern = /\n\tconsole\.log\(\n\t\toptions\.check/u;
-        nextSource = replaceRequiredSyncRestSource(nextSource, "AI_FEATURES", importAnchor, [
-            "import {",
-            "\tAI_FEATURES,",
-            "\tBLOCKS,",
-            "\tREST_RESOURCES,",
-            "\ttype WorkspaceAiFeatureConfig,",
-            "\ttype WorkspaceBlockConfig,",
-            "\ttype WorkspaceRestResourceConfig,",
-            "} from './block-config';",
-        ].join("\n"), "workspace inventory import", syncRestScriptPath);
         nextSource = replaceRequiredSyncRestSource(nextSource, "function isWorkspaceAiFeature(", helperInsertionAnchor, [
             "function isWorkspaceAiFeature(",
             "\tfeature: WorkspaceAiFeatureConfig",
@@ -183,16 +282,10 @@ export async function ensureAiFeatureSyncRestAnchors(workspace) {
             "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );",
             "const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );",
         ].join("\n"), "rest resource filter", syncRestScriptPath);
-        nextSource = replaceRequiredSyncRestSource(nextSource, "restBlocks.length === 0 && restResources.length === 0 && aiFeatures.length === 0", noResourcesPattern, [
-            "if ( restBlocks.length === 0 && restResources.length === 0 && aiFeatures.length === 0 ) {",
-            "\t\tconsole.log(",
-            "\t\t\toptions.check",
-            "\t\t\t\t? 'ℹ️ No REST-enabled workspace blocks, plugin-level REST resources, or AI features are registered yet. `sync-rest --check` is already clean.'",
-            "\t\t\t\t: 'ℹ️ No REST-enabled workspace blocks, plugin-level REST resources, or AI features are registered yet.'",
-            "\t\t);",
-            "\t\treturn;",
-            "\t}",
-        ].join("\n"), "no-resources guard", syncRestScriptPath);
+        nextSource = replaceRequiredSyncRestSource(nextSource, "aiFeatures.length === 0", NO_RESOURCES_GUARD_PATTERN, buildAiFeatureNoResourcesGuard({
+            hasPostMeta: nextSource.includes("const postMetaContracts = POST_META.filter( isWorkspacePostMetaContract );"),
+            hasStandaloneContracts: nextSource.includes("const standaloneContracts = CONTRACTS.filter( isWorkspaceStandaloneContract );"),
+        }), "no-resources guard", syncRestScriptPath);
         nextSource = replaceRequiredSyncRestSource(nextSource, "for ( const feature of aiFeatures ) {", consoleLogPattern, [
             "",
             "\tfor ( const feature of aiFeatures ) {",
@@ -247,7 +340,7 @@ export async function ensureAiFeatureSyncRestAnchors(workspace) {
             "\tconsole.log(",
             "\t\toptions.check",
         ].join("\n"), "final sync summary", syncRestScriptPath);
-        nextSource = replaceRequiredSyncRestSource(nextSource, "workspace blocks, plugin-level resources, and AI features", "workspace blocks and plugin-level resources", "workspace blocks, plugin-level resources, and AI features", "sync summary copy", syncRestScriptPath);
+        nextSource = replaceAiFeatureSyncSummaryCopy(nextSource, syncRestScriptPath);
         return nextSource;
     });
 }

package/dist/runtime/cli-add-workspace-ai-source-emitters.js

@@ -397,7 +397,23 @@ async function reconcileGeneratedArtifact( options: {
 }
 
 async function loadJsonDocument( filePath: string ) {
-\tconst decoded = JSON.parse( await readFile( filePath, 'utf8' ) ) as unknown;
+\tlet source: string;
+\ttry {
+\t\tsource = await readFile( filePath, 'utf8' );
+\t} catch ( error ) {
+\t\tthrow new Error(
+\t\t\t\`Failed to read AI schema document at \${ filePath }: \${ error instanceof Error ? error.message : String( error ) }\`
+\t\t);
+\t}
+
+\tlet decoded: unknown;
+\ttry {
+\t\tdecoded = JSON.parse( source ) as unknown;
+\t} catch ( error ) {
+\t\tthrow new Error(
+\t\t\t\`Failed to parse AI schema document at \${ filePath }: \${ error instanceof Error ? error.message : String( error ) }\`
+\t\t);
+\t}
 \tif ( ! decoded || typeof decoded !== 'object' || Array.isArray( decoded ) ) {
 \t\tthrow new Error( \`Expected \${ filePath } to decode to a JSON object.\` );
 \t}

package/dist/runtime/cli-add-workspace-contract-source-emitters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Render one `CONTRACTS` inventory entry for `scripts/block-config.ts`.
+ *
+ * @param contractSlug Stable kebab-case contract id.
+ * @param sourceTypeName Exported TypeScript type/interface used for schema generation.
+ */
+export declare function buildContractConfigEntry(contractSlug: string, sourceTypeName: string): string;
+/**
+ * Render a small starter TypeScript contract that users can replace with their
+ * real external route, smoke-test, or PHP integration payload shape.
+ *
+ * @param contractSlug Stable kebab-case contract id.
+ * @param sourceTypeName Exported TypeScript type/interface used for schema generation.
+ */
+export declare function buildContractTypesSource(contractSlug: string, sourceTypeName: string): string;

package/dist/runtime/cli-add-workspace-contract-source-emitters.js

@@ -0,0 +1,42 @@
+import { quoteTsString, } from "./cli-add-shared.js";
+import { toTitleCase } from "./string-case.js";
+/**
+ * Render one `CONTRACTS` inventory entry for `scripts/block-config.ts`.
+ *
+ * @param contractSlug Stable kebab-case contract id.
+ * @param sourceTypeName Exported TypeScript type/interface used for schema generation.
+ */
+export function buildContractConfigEntry(contractSlug, sourceTypeName) {
+    return [
+        "\t{",
+        `\t\tschemaFile: ${quoteTsString(`src/contracts/${contractSlug}.schema.json`)},`,
+        `\t\tslug: ${quoteTsString(contractSlug)},`,
+        `\t\tsourceTypeName: ${quoteTsString(sourceTypeName)},`,
+        `\t\ttypesFile: ${quoteTsString(`src/contracts/${contractSlug}.ts`)},`,
+        "\t},",
+    ].join("\n");
+}
+/**
+ * Render a small starter TypeScript contract that users can replace with their
+ * real external route, smoke-test, or PHP integration payload shape.
+ *
+ * @param contractSlug Stable kebab-case contract id.
+ * @param sourceTypeName Exported TypeScript type/interface used for schema generation.
+ */
+export function buildContractTypesSource(contractSlug, sourceTypeName) {
+    const title = toTitleCase(contractSlug);
+    return `/**
+ * ${title} is a standalone wire contract.
+ *
+ * It does not register a WordPress REST route. Edit this type, then run
+ * \`wp-typia sync-rest\` or \`wp-typia sync\` to refresh the JSON Schema
+ * artifact referenced from scripts/block-config.ts.
+ */
+export interface ${sourceTypeName} {
+\tid: string;
+\tstatus: 'pending' | 'ready';
+\tupdatedAt: string;
+\tmessage?: string;
+}
+`;
+}

package/dist/runtime/cli-add-workspace-contract.d.ts

@@ -0,0 +1,15 @@
+import { type RunAddContractCommandOptions } from "./cli-add-shared.js";
+/**
+ * Scaffold a standalone TypeScript wire contract and synchronize its JSON
+ * Schema artifact without generating PHP route glue.
+ *
+ * @param options Command options for the standalone contract workflow.
+ * @returns Resolved scaffold metadata for the created contract.
+ */
+export declare function runAddContractCommand({ contractName, cwd, typeName, }: RunAddContractCommandOptions): Promise<{
+    contractSlug: string;
+    projectDir: string;
+    schemaFile: string;
+    sourceTypeName: string;
+    typesFile: string;
+}>;

package/dist/runtime/cli-add-workspace-contract.js

@@ -0,0 +1,65 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { pathExists } from "./fs-async.js";
+import { assertContractDoesNotExist, assertValidGeneratedSlug, assertValidTypeScriptIdentifier, normalizeBlockSlug, } from "./cli-add-shared.js";
+import { executeWorkspaceMutationPlan } from "./cli-add-workspace-mutation.js";
+import { ensureContractSyncScriptAnchors } from "./cli-add-workspace-rest-anchors.js";
+import { buildContractConfigEntry, buildContractTypesSource, } from "./cli-add-workspace-contract-source-emitters.js";
+import { syncStandaloneContractArtifacts } from "./contract-artifacts.js";
+import { toPascalCase } from "./string-case.js";
+import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
+import { resolveWorkspaceProject } from "./workspace-project.js";
+const ADD_CONTRACT_USAGE = "wp-typia add contract <name> [--type <ExportedTypeName>]";
+/**
+ * Scaffold a standalone TypeScript wire contract and synchronize its JSON
+ * Schema artifact without generating PHP route glue.
+ *
+ * @param options Command options for the standalone contract workflow.
+ * @returns Resolved scaffold metadata for the created contract.
+ */
+export async function runAddContractCommand({ contractName, cwd = process.cwd(), typeName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const contractSlug = assertValidGeneratedSlug("Contract name", normalizeBlockSlug(contractName), ADD_CONTRACT_USAGE);
+    const sourceTypeName = assertValidTypeScriptIdentifier("Contract type", typeName ?? toPascalCase(contractSlug), ADD_CONTRACT_USAGE);
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+    assertContractDoesNotExist(workspace.projectDir, contractSlug, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    const contractDir = path.join(workspace.projectDir, "src", "contracts");
+    const typesFile = `src/contracts/${contractSlug}.ts`;
+    const schemaFile = `src/contracts/${contractSlug}.schema.json`;
+    const typesFilePath = path.join(workspace.projectDir, typesFile);
+    const schemaFilePath = path.join(workspace.projectDir, schemaFile);
+    const contractDirExisted = await pathExists(contractDir);
+    return executeWorkspaceMutationPlan({
+        filePaths: [blockConfigPath, syncRestScriptPath],
+        targetPaths: [
+            typesFilePath,
+            schemaFilePath,
+            ...(contractDirExisted ? [] : [contractDir]),
+        ],
+        run: async () => {
+            await fsp.mkdir(contractDir, { recursive: true });
+            await ensureContractSyncScriptAnchors(workspace);
+            await fsp.writeFile(typesFilePath, buildContractTypesSource(contractSlug, sourceTypeName), "utf8");
+            await syncStandaloneContractArtifacts({
+                projectDir: workspace.projectDir,
+                schemaFile,
+                sourceTypeName,
+                typesFile,
+            });
+            await appendWorkspaceInventoryEntries(workspace.projectDir, {
+                contractEntries: [
+                    buildContractConfigEntry(contractSlug, sourceTypeName),
+                ],
+            });
+            return {
+                contractSlug,
+                projectDir: workspace.projectDir,
+                schemaFile,
+                sourceTypeName,
+                typesFile,
+            };
+        },
+    });
+}

package/dist/runtime/cli-add-workspace-integration-env.d.ts

@@ -0,0 +1,26 @@
+import { type IntegrationEnvServiceId, type RunAddIntegrationEnvCommandOptions } from "./cli-add-shared.js";
+/**
+ * Runtime result returned after adding an integration environment starter.
+ *
+ * @property integrationEnvSlug Normalized slug used for generated script and
+ * documentation paths.
+ * @property projectDir Absolute official workspace directory that was updated.
+ * @property service Canonical local service starter id selected for the scaffold.
+ * @property warnings Optional non-fatal preservation notices for existing files
+ * or scripts.
+ * @property withReleaseZip Whether release zip packaging scripts were added.
+ * @property withWpEnv Whether the generated scaffold included the wp-env preset.
+ */
+export interface RunAddIntegrationEnvCommandResult {
+    integrationEnvSlug: string;
+    projectDir: string;
+    service: IntegrationEnvServiceId;
+    warnings?: string[];
+    withReleaseZip: boolean;
+    withWpEnv: boolean;
+}
+/**
+ * Add an opt-in local WordPress integration environment starter to an official
+ * workspace.
+ */
+export declare function runAddIntegrationEnvCommand({ cwd, integrationEnvName, service, withReleaseZip, withWpEnv, }: RunAddIntegrationEnvCommandOptions): Promise<RunAddIntegrationEnvCommandResult>;