@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/add/cli-add-workspace-registration-hooks.js

@@ -0,0 +1,162 @@
+import path from "node:path";
+import { patchFile } from "./cli-add-shared.js";
+import { findExecutablePatternMatch, hasExecutablePattern, hasUncommentedPattern, maskTypeScriptCommentsAndLiterals, } from "../shared/ts-source-masking.js";
+const SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+function isIdentifierBoundary(source, index) {
+    if (index < 0 || index >= source.length) {
+        return true;
+    }
+    return !/[A-Za-z0-9_$]/u.test(source[index] ?? "");
+}
+function skipWhitespace(source, index) {
+    let cursor = index;
+    while (cursor < source.length && /\s/u.test(source[cursor] ?? "")) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function findMatchingDelimiterEnd(source, openIndex, openDelimiter, closeDelimiter) {
+    let depth = 0;
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === openDelimiter) {
+            depth += 1;
+            continue;
+        }
+        if (char === closeDelimiter) {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Find the first executable call expression for a named function in source code.
+ *
+ * @param source TypeScript or JavaScript source text to scan.
+ * @param callName Function identifier to locate.
+ * @returns The source range for the first matching executable call, or
+ * `undefined` when the identifier is absent, commented, string-literal-only, or
+ * not followed by a call expression.
+ */
+export function findExecutableCallRange(source, callName) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    let searchIndex = 0;
+    while (searchIndex < maskedSource.length) {
+        const callNameIndex = maskedSource.indexOf(callName, searchIndex);
+        if (callNameIndex === -1) {
+            return undefined;
+        }
+        const callNameEnd = callNameIndex + callName.length;
+        if (!isIdentifierBoundary(maskedSource, callNameIndex - 1) ||
+            !isIdentifierBoundary(maskedSource, callNameEnd)) {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        let cursor = skipWhitespace(maskedSource, callNameEnd);
+        if (maskedSource[cursor] === "<") {
+            const genericEnd = findMatchingDelimiterEnd(maskedSource, cursor, "<", ">");
+            if (genericEnd === undefined) {
+                searchIndex = callNameEnd;
+                continue;
+            }
+            cursor = skipWhitespace(maskedSource, genericEnd);
+        }
+        if (maskedSource[cursor] !== "(") {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        const callEnd = findMatchingDelimiterEnd(maskedSource, cursor, "(", ")");
+        if (callEnd === undefined) {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        let end = skipWhitespace(maskedSource, callEnd);
+        if (maskedSource[end] === ";") {
+            end += 1;
+        }
+        return {
+            end,
+            start: callNameIndex,
+        };
+    }
+    return undefined;
+}
+function findBlockRegistrationCallRange(source) {
+    return (findExecutableCallRange(source, "registerScaffoldBlockType") ??
+        findExecutableCallRange(source, "registerBlockType"));
+}
+/**
+ * Ensure a block entrypoint imports and calls a workspace registration helper.
+ *
+ * @param options Entrypoint patch options.
+ * @param options.blockIndexPath Absolute path to the block entrypoint file.
+ * @param options.callLine Call expression line to insert when missing.
+ * @param options.callPattern Executable pattern used to detect an existing call.
+ * @param options.importLine Import line to prepend when missing.
+ * @param options.importPattern Uncommented import pattern used to avoid duplicates.
+ * @returns A promise that resolves after the entrypoint has been patched.
+ * @throws {Error} When the call cannot be injected or verified.
+ */
+export async function ensureWorkspaceEntrypointCall({ blockIndexPath, callLine, callPattern, importLine, importPattern, }) {
+    await patchFile(blockIndexPath, (source) => {
+        let nextSource = source;
+        if (!hasUncommentedPattern(nextSource, importPattern)) {
+            nextSource = `${importLine}\n${nextSource}`;
+        }
+        if (!hasExecutablePattern(nextSource, callPattern)) {
+            const callRange = findBlockRegistrationCallRange(nextSource);
+            if (callRange) {
+                nextSource = [
+                    nextSource.slice(0, callRange.end),
+                    `\n${callLine}\n`,
+                    nextSource.slice(callRange.end),
+                ].join("");
+            }
+            else {
+                nextSource = `${nextSource.trimEnd()}\n\n${callLine}\n`;
+            }
+        }
+        if (!hasExecutablePattern(nextSource, callPattern)) {
+            throw new Error(`Unable to inject ${callLine} into ${path.basename(blockIndexPath)}.`);
+        }
+        return nextSource;
+    });
+}
+/**
+ * Ensure a scaffold block registration settings hook is imported and called.
+ *
+ * @param options Registration settings patch options.
+ * @param options.blockIndexPath Absolute path to the block entrypoint file.
+ * @param options.callLine Settings mutation call to insert before registration.
+ * @param options.callPattern Executable pattern used to detect an existing call.
+ * @param options.importLine Import line to prepend when missing.
+ * @param options.importPattern Uncommented import pattern used to avoid duplicates.
+ * @returns A promise that resolves after the entrypoint has been patched.
+ * @throws {Error} When the entrypoint does not expose the expected
+ * `registerScaffoldBlockType(registration.name, registration.settings)` call.
+ */
+export async function ensureWorkspaceRegistrationSettingsCall({ blockIndexPath, callLine, callPattern, importLine, importPattern, }) {
+    await patchFile(blockIndexPath, (source) => {
+        let nextSource = source;
+        if (!hasUncommentedPattern(nextSource, importPattern)) {
+            nextSource = `${importLine}\n${nextSource}`;
+        }
+        if (!hasExecutablePattern(nextSource, callPattern)) {
+            const callRange = findExecutablePatternMatch(nextSource, [
+                SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN,
+            ]);
+            if (!callRange) {
+                throw new Error(`Unable to inject ${callLine} into ${path.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+            }
+            nextSource = [
+                nextSource.slice(0, callRange.start),
+                `${callLine}\n`,
+                nextSource.slice(callRange.start),
+            ].join("");
+        }
+        return nextSource;
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Compatibility facade for REST workspace anchor patchers.
+ *
+ * Keep the public runtime import path stable while bootstrap, contract sync,
+ * and REST resource sync patchers live in focused implementation modules.
+ */
+export { ensureRestResourceBootstrapAnchors, ensureRestSchemaHelperBootstrapAnchors, } from "./cli-add-workspace-rest-bootstrap-anchors.js";
+export { ensureContractSyncScriptAnchors, } from "./cli-add-workspace-rest-contract-sync-anchors.js";
+export { ensureRestResourceSyncScriptAnchors, } from "./cli-add-workspace-rest-resource-sync-anchors.js";

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

@@ -0,0 +1,9 @@
+/**
+ * Compatibility facade for REST workspace anchor patchers.
+ *
+ * Keep the public runtime import path stable while bootstrap, contract sync,
+ * and REST resource sync patchers live in focused implementation modules.
+ */
+export { ensureRestResourceBootstrapAnchors, ensureRestSchemaHelperBootstrapAnchors, } from "./cli-add-workspace-rest-bootstrap-anchors.js";
+export { ensureContractSyncScriptAnchors, } from "./cli-add-workspace-rest-contract-sync-anchors.js";
+export { ensureRestResourceSyncScriptAnchors, } from "./cli-add-workspace-rest-resource-sync-anchors.js";

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

@@ -0,0 +1,17 @@
+import type { WorkspaceProject } from "../workspace/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>;
+/**
+ * Ensure the workspace bootstrap loads generated REST resource PHP modules.
+ *
+ * @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 generated REST modules.
+ */
+export declare function ensureRestResourceBootstrapAnchors(workspace: WorkspaceProject): Promise<void>;

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

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
+import { hasPhpFunctionDefinition } from "../shared/php-utils.js";
+const REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
+const REST_SCHEMA_HELPER_PATH = "/inc/rest-schema.php";
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+/**
+ * Check that an expected generated path appears inside the named PHP function.
+ *
+ * @param source Complete PHP bootstrap source.
+ * @param functionName PHP function name to inspect.
+ * @param needle Source fragment that must be present inside the function block.
+ * @returns True when the named function block contains the expected fragment.
+ */
+function phpFunctionBlockIncludes(source, functionName, needle) {
+    const functionMatch = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u").exec(source);
+    if (functionMatch === null) {
+        return false;
+    }
+    const start = functionMatch.index;
+    const remainder = source.slice(start + 1);
+    const nextFunctionMatch = /\nfunction\s+/u.exec(remainder);
+    const nextFunction = nextFunctionMatch === null ? -1 : start + 1 + nextFunctionMatch.index;
+    const closingTag = source.indexOf("\n?>", start + 1);
+    const endCandidates = [nextFunction, closingTag].filter((index) => index !== -1);
+    const end = endCandidates.length > 0 ? Math.min(...endCandidates) : source.length;
+    return source.slice(start, end).includes(needle);
+}
+/**
+ * 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 (!phpFunctionBlockIncludes(nextSource, loadFunctionName, 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;
+    });
+}
+/**
+ * Ensure the workspace bootstrap loads generated REST resource PHP modules.
+ *
+ * @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 generated REST modules.
+ */
+export async function ensureRestResourceBootstrapAnchors(workspace) {
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    await patchFile(bootstrapPath, (source) => {
+        let nextSource = source;
+        const registerFunctionName = `${workspace.workspace.phpPrefix}_register_rest_resources`;
+        const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+        const registerFunction = `
+
+function ${registerFunctionName}() {
+\tforeach ( glob( __DIR__ . '${REST_RESOURCE_SERVER_GLOB}' ) ?: array() as $rest_resource_module ) {
+\t\trequire_once $rest_resource_module;
+\t}
+}
+`;
+        if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, registerFunction);
+        }
+        else if (!phpFunctionBlockIncludes(nextSource, registerFunctionName, REST_RESOURCE_SERVER_GLOB)) {
+            throw new Error([
+                `Unable to patch ${path.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+                `The existing ${registerFunctionName}() definition does not include ${REST_RESOURCE_SERVER_GLOB}.`,
+                "Restore the generated bootstrap shape or wire the REST resource loader manually before retrying.",
+            ].join(" "));
+        }
+        if (!nextSource.includes(registerHook)) {
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, registerHook);
+        }
+        return nextSource;
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Ensure sync-rest can repair and validate standalone workspace contracts.
+ *
+ * @param workspace Workspace project whose sync-rest script should be patched.
+ * @returns A promise that resolves after the sync-rest script is updated.
+ * @throws When the generated sync-rest anchors cannot be found.
+ */
+export declare function ensureContractSyncScriptAnchors(workspace: WorkspaceProject): Promise<void>;

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

@@ -0,0 +1,142 @@
+import path from "node:path";
+import { patchFile } from "./cli-add-shared.js";
+import { buildNoResourcesGuard, getSyncRestPatchErrorMessage, replaceBlockConfigImport, replaceNoResourcesGuard, } from "./cli-add-workspace-rest-sync-script-shared.js";
+function replaceRequiredContractSyncRestSource(nextSource, target, anchor, replacement, anchorDescription, syncRestScriptPath) {
+    if (nextSource.includes(target)) {
+        return nextSource;
+    }
+    const hasAnchor = typeof anchor === "string" ? nextSource.includes(anchor) : anchor.test(nextSource);
+    if (!hasAnchor) {
+        throw new Error(getSyncRestPatchErrorMessage("ensureContractSyncScriptAnchors", syncRestScriptPath, anchorDescription, "CONTRACTS"));
+    }
+    return nextSource.replace(anchor, replacement);
+}
+function insertStandaloneContractFilter(nextSource, syncRestScriptPath) {
+    if (nextSource.includes("const standaloneContracts = CONTRACTS.filter")) {
+        return nextSource;
+    }
+    const restResourcesFilter = "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );";
+    if (nextSource.includes(restResourcesFilter)) {
+        return nextSource.replace(restResourcesFilter, [
+            "const standaloneContracts = CONTRACTS.filter( isWorkspaceStandaloneContract );",
+            restResourcesFilter,
+        ].join("\n\t"));
+    }
+    const restBlocksFilter = "const restBlocks = BLOCKS.filter( isRestEnabledBlock );";
+    return replaceRequiredContractSyncRestSource(nextSource, "const standaloneContracts = CONTRACTS.filter", restBlocksFilter, [
+        restBlocksFilter,
+        "const standaloneContracts = CONTRACTS.filter( isWorkspaceStandaloneContract );",
+    ].join("\n\t"), "restBlocks filter", syncRestScriptPath);
+}
+function insertStandaloneContractNoResourcesGuard(nextSource, syncRestScriptPath) {
+    const hasRestResources = nextSource.includes("const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );");
+    const hasAiFeatures = nextSource.includes("const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );");
+    const hasPostMeta = nextSource.includes("const postMetaContracts = POST_META.filter( isWorkspacePostMetaContract );");
+    return replaceNoResourcesGuard(nextSource, buildNoResourcesGuard({
+        subjects: [
+            {
+                condition: "restBlocks.length === 0",
+                include: true,
+                subject: "REST-enabled workspace blocks",
+            },
+            {
+                condition: "standaloneContracts.length === 0",
+                include: true,
+                subject: "standalone contracts",
+            },
+            {
+                condition: "postMetaContracts.length === 0",
+                include: hasPostMeta,
+                subject: "post meta contracts",
+            },
+            {
+                condition: "restResources.length === 0",
+                include: hasRestResources,
+                subject: "plugin-level REST resources",
+            },
+            {
+                condition: "aiFeatures.length === 0",
+                include: hasAiFeatures,
+                subject: "AI features",
+            },
+        ],
+    }), "ensureContractSyncScriptAnchors", syncRestScriptPath, "CONTRACTS");
+}
+function insertStandaloneContractSyncLoop(nextSource, syncRestScriptPath) {
+    if (nextSource.includes("for ( const contract of standaloneContracts )")) {
+        return nextSource;
+    }
+    const loopSource = [
+        "\tfor ( const contract of standaloneContracts ) {",
+        "\t\tawait syncTypeSchemas(",
+        "\t\t\t{",
+        "\t\t\t\tjsonSchemaFile: contract.schemaFile,",
+        "\t\t\t\tsourceTypeName: contract.sourceTypeName,",
+        "\t\t\t\ttypesFile: contract.typesFile,",
+        "\t\t\t},",
+        "\t\t\t{",
+        "\t\t\t\tcheck: options.check,",
+        "\t\t\t}",
+        "\t\t);",
+        "\t}",
+    ].join("\n");
+    const resourceLoopAnchor = "\n\tfor ( const resource of restResources ) {";
+    if (nextSource.includes(resourceLoopAnchor)) {
+        return nextSource.replace(resourceLoopAnchor, `\n${loopSource}\n${resourceLoopAnchor}`);
+    }
+    const consoleLogPattern = /\n\tconsole\.log\(\n\t\toptions\.check/u;
+    return replaceRequiredContractSyncRestSource(nextSource, "for ( const contract of standaloneContracts )", consoleLogPattern, [
+        "",
+        loopSource,
+        "",
+        "\tconsole.log(",
+        "\t\toptions.check",
+    ].join("\n"), "success log insertion point", syncRestScriptPath);
+}
+/**
+ * Ensure sync-rest can repair and validate standalone workspace contracts.
+ *
+ * @param workspace Workspace project whose sync-rest script should be patched.
+ * @returns A promise that resolves after the sync-rest script is updated.
+ * @throws When the generated sync-rest anchors cannot be found.
+ */
+export async function ensureContractSyncScriptAnchors(workspace) {
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    await patchFile(syncRestScriptPath, (source) => {
+        let nextSource = replaceBlockConfigImport({
+            functionName: "ensureContractSyncScriptAnchors",
+            nextSource: source,
+            subject: {
+                configTypeName: "WorkspaceContractConfig",
+                constName: "CONTRACTS",
+            },
+            syncRestScriptPath,
+        });
+        const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
+        nextSource = replaceRequiredContractSyncRestSource(nextSource, "function isWorkspaceStandaloneContract(", helperInsertionAnchor, [
+            "function isWorkspaceStandaloneContract(",
+            "\tcontract: WorkspaceContractConfig",
+            "): contract is WorkspaceContractConfig & {",
+            "\tschemaFile: string;",
+            "\tsourceTypeName: string;",
+            "\ttypesFile: string;",
+            "} {",
+            "\treturn (",
+            "\t\ttypeof contract.schemaFile === 'string' &&",
+            "\t\ttypeof contract.sourceTypeName === 'string' &&",
+            "\t\ttypeof contract.typesFile === 'string'",
+            "\t);",
+            "}",
+            "",
+            "async function assertTypeArtifactsCurrent",
+        ].join("\n"), "type artifact assertion helper", syncRestScriptPath);
+        nextSource = insertStandaloneContractFilter(nextSource, syncRestScriptPath);
+        nextSource = insertStandaloneContractNoResourcesGuard(nextSource, syncRestScriptPath);
+        nextSource = insertStandaloneContractSyncLoop(nextSource, syncRestScriptPath);
+        nextSource = nextSource.replace("✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date for workspace blocks and plugin-level resources!", "✅ REST contract schemas, standalone schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date for workspace blocks, standalone contracts, and plugin-level resources!");
+        nextSource = nextSource.replace("✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents generated for workspace blocks and plugin-level resources!", "✅ REST contract schemas, standalone schemas, portable API clients, and endpoint-aware OpenAPI documents generated for workspace blocks, standalone contracts, and plugin-level resources!");
+        nextSource = nextSource.replace("✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date with the TypeScript types!", "✅ REST contract schemas, standalone schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date with the TypeScript types!");
+        nextSource = nextSource.replace("✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents generated from TypeScript types!", "✅ REST contract schemas, standalone schemas, portable API clients, and endpoint-aware OpenAPI documents generated from TypeScript types!");
+        return nextSource;
+    });
+}

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

@@ -0,0 +1,51 @@
+import { type RestResourceMethodId } from "./cli-add-shared.js";
+/**
+ * Build a generated REST resource config entry for `scripts/block-config.ts`.
+ *
+ * @param options REST resource metadata. `restResourceSlug`, `namespace`, and
+ * `methods` are required; `controllerClass`, `controllerExtends`,
+ * `permissionCallback`, and `routePattern` opt into generated controller,
+ * permission, and item-route escape hatches.
+ * @returns TypeScript object literal source for one generated REST resource entry.
+ */
+export declare function buildRestResourceConfigEntry(options: {
+    controllerClass?: string;
+    controllerExtends?: string;
+    methods: RestResourceMethodId[];
+    namespace: string;
+    permissionCallback?: string;
+    restResourceSlug: string;
+    routePattern?: string;
+}): string;
+/**
+ * Build editable TypeScript type definitions for a generated REST resource.
+ *
+ * @param restResourceSlug Normalized REST resource slug.
+ * @param methods Enabled generated REST methods.
+ * @returns TypeScript source for `api-types.ts`.
+ */
+export declare function buildRestResourceTypesSource(restResourceSlug: string, methods: RestResourceMethodId[]): string;
+/**
+ * Build Typia validators for a generated REST resource.
+ *
+ * @param restResourceSlug Normalized REST resource slug.
+ * @param methods Enabled generated REST methods.
+ * @returns TypeScript source for `api-validators.ts`.
+ */
+export declare function buildRestResourceValidatorsSource(restResourceSlug: string, methods: RestResourceMethodId[]): string;
+/**
+ * Build the public API shim for a generated REST resource.
+ *
+ * @param restResourceSlug Normalized REST resource slug.
+ * @param methods Enabled generated REST methods.
+ * @returns TypeScript source for `api.ts`.
+ */
+export declare function buildRestResourceApiSource(restResourceSlug: string, methods: RestResourceMethodId[]): string;
+/**
+ * Build React query and mutation hooks for a generated REST resource.
+ *
+ * @param restResourceSlug Normalized REST resource slug.
+ * @param methods Enabled generated REST methods.
+ * @returns TypeScript source for `data.ts`.
+ */
+export declare function buildRestResourceDataSource(restResourceSlug: string, methods: RestResourceMethodId[]): string;