@wp-typia/project-tools 0.23.0 → 0.23.1

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",

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-integration-env.d.ts

@@ -8,6 +8,7 @@ import { type IntegrationEnvServiceId, type RunAddIntegrationEnvCommandOptions }
  * @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 {
@@ -15,10 +16,11 @@ export interface RunAddIntegrationEnvCommandResult {
     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, withWpEnv, }: RunAddIntegrationEnvCommandOptions): Promise<RunAddIntegrationEnvCommandResult>;
+export declare function runAddIntegrationEnvCommand({ cwd, integrationEnvName, service, withReleaseZip, withWpEnv, }: RunAddIntegrationEnvCommandOptions): Promise<RunAddIntegrationEnvCommandResult>;

package/dist/runtime/cli-add-workspace-integration-env.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { assertValidGeneratedSlug, assertValidIntegrationEnvService, normalizeBlockSlug, } from "./cli-add-shared.js";
 import { formatRunScript, } from "./package-managers.js";
 import { pathExists, readOptionalUtf8File } from "./fs-async.js";
+import { readJsonFile } from "./json-utils.js";
 import { executeWorkspaceMutationPlan } from "./cli-add-workspace-mutation.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { toTitleCase } from "./string-case.js";
@@ -136,6 +137,11 @@ const baseUrl = new URL(
 );
 const serviceUrl = getEnv("WP_TYPIA_SERVICE_URL", "").trim();
 
+// Extend this starter with project-specific generated REST clients or schema
+// checks as the workspace grows. For example, read JSON schemas under
+// src/rest/<resource>/api-schemas or import TS clients through a tsx-powered
+// smoke runner when you need authenticated route coverage.
+
 await assertJsonEndpoint(
 	"WordPress REST index",
 	resolveEndpointUrl(baseUrl, "wp-json/"),
@@ -171,7 +177,7 @@ function buildEnvExampleSource(service) {
         "",
     ].join("\n");
 }
-function buildIntegrationEnvReadmeSource({ integrationEnvSlug, service, withWpEnv, }) {
+function buildIntegrationEnvReadmeSource({ integrationEnvSlug, service, withReleaseZip, withWpEnv, }) {
     const title = toTitleCase(integrationEnvSlug);
     const setupSteps = [
         "Copy `.env.example` to `.env` and adjust the URLs or credentials for your local project.",
@@ -190,6 +196,11 @@ function buildIntegrationEnvReadmeSource({ integrationEnvSlug, service, withWpEn
                 "Set `WP_TYPIA_SERVICE_URL` only when your integration smoke needs a local service dependency.",
             ]),
         `Run \`npm run smoke:${integrationEnvSlug}\` to execute the starter smoke check.`,
+        ...(withReleaseZip
+            ? [
+                "Run `npm run release:zip` after smoke checks pass to build a distributable plugin zip.",
+            ]
+            : []),
     ];
     return `# ${title} Integration Environment
 
@@ -211,6 +222,7 @@ ${setupSteps.map((step, index) => `${index + 1}. ${step}`).join("\n")}
   emulator containers.
 - Keep the smoke script focused on high-signal integration checks so CI and
   local debugging stay fast.
+${withReleaseZip ? "- Treat `release:zip:check` as a CI guard before packaging release artifacts.\n" : ""}
 `;
 }
 async function appendMissingLines(filePath, lines) {
@@ -249,11 +261,13 @@ function addScriptIfMissing({ scriptName, scripts, scriptValue, warnings, }) {
 }
 async function mutatePackageJson(projectDir, mutate) {
     const packageJsonPath = path.join(projectDir, "package.json");
-    const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+    const packageJson = await readJsonFile(packageJsonPath, {
+        context: "integration env package manifest",
+    });
     mutate(packageJson);
     await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
 }
-function addIntegrationEnvPackageJsonEntries({ integrationEnvSlug, packageManager, packageJson, service, warnings, withWpEnv, }) {
+function addIntegrationEnvPackageJsonEntries({ integrationEnvSlug, packageManager, packageJson, withReleaseZip, service, warnings, withWpEnv, }) {
     const devDependencies = {
         ...(packageJson.devDependencies ?? {}),
     };
@@ -296,6 +310,26 @@ function addIntegrationEnvPackageJsonEntries({ integrationEnvSlug, packageManage
             warnings,
         });
     }
+    if (withReleaseZip) {
+        addScriptIfMissing({
+            scriptName: "release:zip",
+            scriptValue: `${formatRunScript(packageManager, "sync-rest:package")} && ${formatRunScript(packageManager, "build")} && wp-scripts plugin-zip`,
+            scripts,
+            warnings,
+        });
+        addScriptIfMissing({
+            scriptName: "release:zip:check",
+            scriptValue: `${formatRunScript(packageManager, "sync-rest:package:check")} && ${formatRunScript(packageManager, "build")}`,
+            scripts,
+            warnings,
+        });
+        addScriptIfMissing({
+            scriptName: "qa:check",
+            scriptValue: `${formatRunScript(packageManager, "wp-typia:doctor:workspace")} && ${formatRunScript(packageManager, "release:zip:check")}`,
+            scripts,
+            warnings,
+        });
+    }
     if (service === "docker-compose") {
         addScriptIfMissing({
             scriptName: "service:start",
@@ -316,9 +350,9 @@ function addIntegrationEnvPackageJsonEntries({ integrationEnvSlug, packageManage
  * Add an opt-in local WordPress integration environment starter to an official
  * workspace.
  */
-export async function runAddIntegrationEnvCommand({ cwd = process.cwd(), integrationEnvName, service, withWpEnv = false, }) {
+export async function runAddIntegrationEnvCommand({ cwd = process.cwd(), integrationEnvName, service, withReleaseZip = false, withWpEnv = false, }) {
     const workspace = resolveWorkspaceProject(cwd);
-    const integrationEnvSlug = assertValidGeneratedSlug("Integration environment name", normalizeBlockSlug(integrationEnvName), "wp-typia add integration-env <name> [--wp-env]");
+    const integrationEnvSlug = assertValidGeneratedSlug("Integration environment name", normalizeBlockSlug(integrationEnvName), "wp-typia add integration-env <name> [--wp-env] [--release-zip]");
     const serviceId = assertValidIntegrationEnvService(service);
     const warnings = [];
     const packageJsonPath = path.join(workspace.projectDir, "package.json");
@@ -351,6 +385,7 @@ export async function runAddIntegrationEnvCommand({ cwd = process.cwd(), integra
             await writeNewScaffoldFile(docsPath, buildIntegrationEnvReadmeSource({
                 integrationEnvSlug,
                 service: serviceId,
+                withReleaseZip,
                 withWpEnv,
             }));
             await appendMissingLines(envExamplePath, [
@@ -376,6 +411,7 @@ export async function runAddIntegrationEnvCommand({ cwd = process.cwd(), integra
                 packageManager: workspace.packageManager,
                 packageJson,
                 service: serviceId,
+                withReleaseZip,
                 warnings,
                 withWpEnv,
             }));
@@ -386,6 +422,7 @@ export async function runAddIntegrationEnvCommand({ cwd = process.cwd(), integra
         projectDir: workspace.projectDir,
         service: serviceId,
         warnings: warnings.length > 0 ? warnings : undefined,
+        withReleaseZip,
         withWpEnv,
     };
 }

package/dist/runtime/cli-add-workspace-rest-anchors.d.ts

@@ -1,4 +1,12 @@
 import type { WorkspaceProject } from "./workspace-project.js";
+/**
+ * Ensure the workspace bootstrap loads the shared REST schema helper file.
+ *
+ * @param workspace Resolved workspace project metadata and PHP prefix.
+ * @returns A promise that resolves after the bootstrap is patched.
+ * @throws When an existing loader does not reference `inc/rest-schema.php`.
+ */
+export declare function ensureRestSchemaHelperBootstrapAnchors(workspace: WorkspaceProject): Promise<void>;
 export declare function ensureRestResourceBootstrapAnchors(workspace: WorkspaceProject): Promise<void>;
 export declare function ensureContractSyncScriptAnchors(workspace: WorkspaceProject): Promise<void>;
 export declare function ensureRestResourceSyncScriptAnchors(workspace: WorkspaceProject): Promise<void>;

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

@@ -3,6 +3,47 @@ import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
 import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
 import { hasPhpFunctionDefinition } from "./php-utils.js";
 const REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
+const REST_SCHEMA_HELPER_PATH = "/inc/rest-schema.php";
+/**
+ * Ensure the workspace bootstrap loads the shared REST schema helper file.
+ *
+ * @param workspace Resolved workspace project metadata and PHP prefix.
+ * @returns A promise that resolves after the bootstrap is patched.
+ * @throws When an existing loader does not reference `inc/rest-schema.php`.
+ */
+export async function ensureRestSchemaHelperBootstrapAnchors(workspace) {
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    await patchFile(bootstrapPath, (source) => {
+        let nextSource = source;
+        const loadFunctionName = `${workspace.workspace.phpPrefix}_load_rest_schema_helpers`;
+        const loadCall = `${loadFunctionName}();`;
+        const helperFunction = `
+
+function ${loadFunctionName}() {
+\t$helper_path = __DIR__ . '${REST_SCHEMA_HELPER_PATH}';
+\tif ( is_readable( $helper_path ) ) {
+\t\trequire_once $helper_path;
+\t}
+}
+
+${loadCall}
+`;
+        if (!hasPhpFunctionDefinition(nextSource, loadFunctionName)) {
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, helperFunction);
+        }
+        else if (!nextSource.includes(REST_SCHEMA_HELPER_PATH)) {
+            throw new Error([
+                `Unable to patch ${path.basename(bootstrapPath)} in ensureRestSchemaHelperBootstrapAnchors.`,
+                `The existing ${loadFunctionName}() definition does not include ${REST_SCHEMA_HELPER_PATH}.`,
+                "Restore the generated bootstrap shape or load inc/rest-schema.php manually before retrying.",
+            ].join(" "));
+        }
+        else if (!nextSource.includes(loadCall)) {
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, loadCall);
+        }
+        return nextSource;
+    });
+}
 export async function ensureRestResourceBootstrapAnchors(workspace) {
     const bootstrapPath = getWorkspaceBootstrapPath(workspace);
     await patchFile(bootstrapPath, (source) => {

package/dist/runtime/cli-add-workspace-rest-generated.d.ts

@@ -0,0 +1,9 @@
+import { type GeneratedRestResourceScaffoldOptions, type RunAddRestResourceCommandResult } from "./cli-add-workspace-rest-types.js";
+/**
+ * Scaffold generated TypeScript, PHP, schema, and inventory files for a
+ * workspace-owned REST resource.
+ *
+ * @param options Resolved workspace and raw generated-mode command options.
+ * @returns Resolved scaffold metadata for the generated REST resource.
+ */
+export declare function scaffoldGeneratedRestResource({ controllerClass, controllerExtends, methods, namespace, permissionCallback, restResourceSlug, routePattern, workspace, }: GeneratedRestResourceScaffoldOptions): Promise<RunAddRestResourceCommandResult>;

package/dist/runtime/cli-add-workspace-rest-generated.js

@@ -0,0 +1,158 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { ensureBlockConfigCanAddRestManifests } from "./cli-add-block-legacy-validator.js";
+import { assertValidRestResourceMethods, getWorkspaceBootstrapPath, resolveGeneratedRestResourceRoutePattern, resolveOptionalPhpCallbackReference, resolveOptionalPhpClassReference, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { ensureRestResourceBootstrapAnchors, ensureRestSchemaHelperBootstrapAnchors, ensureRestResourceSyncScriptAnchors, } from "./cli-add-workspace-rest-anchors.js";
+import { buildRestResourcePhpSource, buildWorkspaceRestSchemaHelperPhpSource, } from "./cli-add-workspace-rest-php-templates.js";
+import { buildRestResourceApiSource, buildRestResourceConfigEntry, buildRestResourceDataSource, buildRestResourceTypesSource, buildRestResourceValidatorsSource, } from "./cli-add-workspace-rest-source-emitters.js";
+import { hasPhpFunctionDefinition } from "./php-utils.js";
+import { syncRestResourceArtifacts } from "./rest-resource-artifacts.js";
+import { toPascalCase, toTitleCase } from "./string-case.js";
+import { appendWorkspaceInventoryEntries } from "./workspace-inventory.js";
+async function ensureWorkspaceRestSchemaHelperFile(helperFilePath, phpPrefix) {
+    let currentSource = null;
+    try {
+        currentSource = await fsp.readFile(helperFilePath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    if (currentSource === null) {
+        await fsp.mkdir(path.dirname(helperFilePath), { recursive: true });
+        await fsp.writeFile(helperFilePath, buildWorkspaceRestSchemaHelperPhpSource(phpPrefix), "utf8");
+        return;
+    }
+    const requiredFunctions = [
+        `${phpPrefix}_load_rest_schema`,
+        `${phpPrefix}_prepare_rest_schema_for_wordpress`,
+        `${phpPrefix}_get_wordpress_rest_schema`,
+        `${phpPrefix}_validate_and_sanitize_rest_payload`,
+    ];
+    const missingFunctions = requiredFunctions.filter((functionName) => !hasPhpFunctionDefinition(currentSource, functionName));
+    if (missingFunctions.length > 0) {
+        throw new Error([
+            `Existing ${path.relative(process.cwd(), helperFilePath)} is missing generated REST schema helper functions: ${missingFunctions.join(", ")}.`,
+            "Restore the generated inc/rest-schema.php helper or add these functions manually before retrying.",
+        ].join(" "));
+    }
+}
+/**
+ * Scaffold generated TypeScript, PHP, schema, and inventory files for a
+ * workspace-owned REST resource.
+ *
+ * @param options Resolved workspace and raw generated-mode command options.
+ * @returns Resolved scaffold metadata for the generated REST resource.
+ */
+export async function scaffoldGeneratedRestResource({ controllerClass, controllerExtends, methods, namespace, permissionCallback, restResourceSlug, routePattern, workspace, }) {
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    const restResourceDir = path.join(workspace.projectDir, "src", "rest", restResourceSlug);
+    const typesFilePath = path.join(restResourceDir, "api-types.ts");
+    const validatorsFilePath = path.join(restResourceDir, "api-validators.ts");
+    const apiFilePath = path.join(restResourceDir, "api.ts");
+    const resolvedMethods = assertValidRestResourceMethods(methods);
+    const resolvedRoutePattern = resolveGeneratedRestResourceRoutePattern(restResourceSlug, routePattern);
+    const hasCustomRoutePattern = typeof routePattern === "string" && routePattern.trim().length > 0;
+    const resolvedPermissionCallback = resolveOptionalPhpCallbackReference("Generated REST resource permission callback", permissionCallback);
+    const resolvedControllerClass = resolveOptionalPhpClassReference("Generated REST resource controller class", controllerClass);
+    const resolvedControllerExtends = resolveOptionalPhpClassReference("Generated REST resource controller base class", controllerExtends);
+    if (resolvedControllerExtends && !resolvedControllerClass) {
+        throw new Error("Generated REST resource controller base class requires --controller-class.");
+    }
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    const dataFilePath = path.join(restResourceDir, "data.ts");
+    const restSchemaHelperPath = path.join(workspace.projectDir, "inc", "rest-schema.php");
+    const phpFilePath = path.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([
+            blockConfigPath,
+            bootstrapPath,
+            restSchemaHelperPath,
+            syncRestScriptPath,
+        ]),
+        snapshotDirs: [],
+        targetPaths: [restResourceDir, restSchemaHelperPath, phpFilePath],
+    };
+    try {
+        await fsp.mkdir(restResourceDir, { recursive: true });
+        await fsp.mkdir(path.dirname(phpFilePath), { recursive: true });
+        await ensureWorkspaceRestSchemaHelperFile(restSchemaHelperPath, workspace.workspace.phpPrefix);
+        await ensureRestSchemaHelperBootstrapAnchors(workspace);
+        await ensureRestResourceBootstrapAnchors(workspace);
+        await ensureRestResourceSyncScriptAnchors(workspace);
+        await fsp.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
+        await fsp.writeFile(validatorsFilePath, buildRestResourceValidatorsSource(restResourceSlug, resolvedMethods), "utf8");
+        await fsp.writeFile(apiFilePath, buildRestResourceApiSource(restResourceSlug, resolvedMethods), "utf8");
+        await fsp.writeFile(dataFilePath, buildRestResourceDataSource(restResourceSlug, resolvedMethods), "utf8");
+        await fsp.writeFile(phpFilePath, buildRestResourcePhpSource(restResourceSlug, namespace, workspace.workspace.phpPrefix, resolvedMethods, {
+            ...(resolvedControllerClass
+                ? { controllerClass: resolvedControllerClass }
+                : {}),
+            ...(resolvedControllerExtends
+                ? { controllerExtends: resolvedControllerExtends }
+                : {}),
+            ...(resolvedPermissionCallback
+                ? { permissionCallback: resolvedPermissionCallback }
+                : {}),
+            routePattern: resolvedRoutePattern,
+        }), "utf8");
+        await syncRestResourceArtifacts({
+            clientFile: `src/rest/${restResourceSlug}/api-client.ts`,
+            methods: resolvedMethods,
+            outputDir: restResourceDir,
+            projectDir: workspace.projectDir,
+            typesFile: `src/rest/${restResourceSlug}/api-types.ts`,
+            validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
+            variables: {
+                namespace,
+                pascalCase: toPascalCase(restResourceSlug),
+                ...(hasCustomRoutePattern ? { routePattern: resolvedRoutePattern } : {}),
+                slugKebabCase: restResourceSlug,
+                title: toTitleCase(restResourceSlug),
+            },
+        });
+        await appendWorkspaceInventoryEntries(workspace.projectDir, {
+            restResourceEntries: [
+                buildRestResourceConfigEntry({
+                    ...(resolvedControllerClass
+                        ? { controllerClass: resolvedControllerClass }
+                        : {}),
+                    ...(resolvedControllerExtends
+                        ? { controllerExtends: resolvedControllerExtends }
+                        : {}),
+                    methods: resolvedMethods,
+                    namespace,
+                    ...(resolvedPermissionCallback
+                        ? { permissionCallback: resolvedPermissionCallback }
+                        : {}),
+                    restResourceSlug,
+                    ...(hasCustomRoutePattern ? { routePattern: resolvedRoutePattern } : {}),
+                }),
+            ],
+            transformSource: ensureBlockConfigCanAddRestManifests,
+        });
+        return {
+            ...(resolvedControllerClass
+                ? { controllerClass: resolvedControllerClass }
+                : {}),
+            ...(resolvedControllerExtends
+                ? { controllerExtends: resolvedControllerExtends }
+                : {}),
+            methods: resolvedMethods,
+            mode: "generated",
+            namespace,
+            ...(resolvedPermissionCallback
+                ? { permissionCallback: resolvedPermissionCallback }
+                : {}),
+            projectDir: workspace.projectDir,
+            restResourceSlug,
+            ...(hasCustomRoutePattern ? { routePattern: resolvedRoutePattern } : {}),
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}

package/dist/runtime/cli-add-workspace-rest-manual.d.ts

@@ -0,0 +1,8 @@
+import { type ManualRestContractScaffoldOptions, type RunAddRestResourceCommandResult } from "./cli-add-workspace-rest-types.js";
+/**
+ * Scaffold a type-only external REST contract for workspace consumers.
+ *
+ * @param options Resolved workspace and raw manual-mode command options.
+ * @returns Resolved scaffold metadata for the manual REST contract.
+ */
+export declare function scaffoldManualRestContract({ auth, bodyTypeName, controllerClass, controllerExtends, method, namespace, pathPattern, permissionCallback, queryTypeName, responseTypeName, restResourceSlug, routePattern, secretFieldName, secretHasValueFieldName, secretMaskedResponseFieldName, secretPreserveOnEmpty, secretStateFieldName, workspace, }: ManualRestContractScaffoldOptions): Promise<RunAddRestResourceCommandResult>;