@wp-typia/project-tools 0.24.3 → 0.24.5

package/dist/runtime/add/pattern-catalog.js

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PATTERN_SECTION_ROLE_PATTERN, collectKnownPatternSectionRoles, normalizePatternCatalogSectionRoleConvention, validatePatternContentSectionRoles, } from "./pattern-catalog-section-roles.js";
+export { extractPatternSectionRoleMatches, extractPatternSectionRolesFromAttributes, PATTERN_SECTION_ROLE_PATTERN, } from "./pattern-catalog-section-roles.js";
+export const PATTERN_CATALOG_SCOPE_IDS = ["full", "section"];
+const PATTERN_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/u;
+export const PATTERN_TAG_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;
+const PATTERN_CONTENT_FILE_ROOT = "src/patterns/";
+function createPatternCatalogDiagnostic(diagnostic) {
+    return diagnostic;
+}
+function isPatternCatalogScope(value) {
+    return PATTERN_CATALOG_SCOPE_IDS.includes(value);
+}
+function isSafeRelativePath(value) {
+    return (value.length > 0 &&
+        !path.isAbsolute(value) &&
+        !value.includes("\\") &&
+        !value.split(/[\\/]+/u).includes("..") &&
+        !/[<>:"|?*\u0000-\u001F]/u.test(value));
+}
+function isPatternContentFilePath(value) {
+    if (!isSafeRelativePath(value) ||
+        !value.startsWith(PATTERN_CONTENT_FILE_ROOT) ||
+        !value.endsWith(".php")) {
+        return false;
+    }
+    const patternRelativePath = value.slice(PATTERN_CONTENT_FILE_ROOT.length);
+    const segments = patternRelativePath.split("/");
+    return ((segments.length === 1 || segments.length === 2) &&
+        segments.every((segment) => segment.length > 0));
+}
+/**
+ * Validate pattern thumbnail references with the same URL/path rules used by
+ * catalog diagnostics and `wp-typia add pattern`.
+ *
+ * @param value Candidate thumbnail URL or relative project path.
+ * @returns Whether the value is an http(s) URL or safe relative project path.
+ */
+export function isValidPatternThumbnailUrl(value) {
+    if (value.length === 0) {
+        return false;
+    }
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return isSafeRelativePath(value);
+    }
+}
+export function resolvePatternCatalogContentFile(pattern) {
+    return pattern.contentFile ?? pattern.file;
+}
+/**
+ * Validate typed pattern catalog metadata declared in `scripts/block-config.ts`.
+ *
+ * The validator checks catalog shape, duplicate slugs, optional section-role
+ * rules, safe content file paths, and missing files when a workspace root is
+ * provided. With a workspace root, it also parses serialized block markup and
+ * compares section role markers against the catalog manifest.
+ *
+ * @param patterns Pattern catalog entries to validate.
+ * @param options Optional project root and section role marker convention.
+ * @returns Structured diagnostics split into errors and warnings.
+ */
+export function validatePatternCatalog(patterns, options = {}) {
+    const diagnostics = [];
+    const seenSlugs = new Map();
+    let sectionRoleConvention = null;
+    if (options.sectionRoleConvention !== false) {
+        try {
+            sectionRoleConvention = normalizePatternCatalogSectionRoleConvention(options.sectionRoleConvention);
+        }
+        catch (error) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-section-role-convention",
+                message: `sectionRoleConvention.roleClassNamePattern is invalid: ${error instanceof Error ? error.message : String(error)}`,
+                severity: "error",
+            }));
+        }
+    }
+    const knownSectionRoles = collectKnownPatternSectionRoles(patterns);
+    for (const [index, pattern] of patterns.entries()) {
+        const label = pattern.slug || `PATTERNS[${index}]`;
+        if (!PATTERN_SLUG_PATTERN.test(pattern.slug)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-slug",
+                message: `${label}: slug must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        const previousIndex = seenSlugs.get(pattern.slug);
+        if (previousIndex !== undefined) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "duplicate-pattern-slug",
+                message: `${label}: duplicate slug already declared at PATTERNS[${previousIndex}].`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        else {
+            seenSlugs.set(pattern.slug, index);
+        }
+        const scope = pattern.scope ?? "full";
+        if (!isPatternCatalogScope(scope)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-scope",
+                message: `${label}: scope must be one of ${PATTERN_CATALOG_SCOPE_IDS.join(", ")}.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        if (scope === "section" && !pattern.sectionRole) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "missing-pattern-section-role",
+                message: `${label}: section-scoped patterns must declare sectionRole.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        if (pattern.sectionRole !== undefined &&
+            !PATTERN_SECTION_ROLE_PATTERN.test(pattern.sectionRole)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-section-role",
+                message: `${label}: sectionRole must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        for (const [tagIndex, tag] of (pattern.tags ?? []).entries()) {
+            if (!PATTERN_TAG_PATTERN.test(tag)) {
+                diagnostics.push(createPatternCatalogDiagnostic({
+                    code: "invalid-pattern-tag",
+                    message: `${label}: tags[${tagIndex}] must contain only lowercase letters, numbers, and hyphens.`,
+                    patternSlug: pattern.slug,
+                    severity: "error",
+                }));
+            }
+        }
+        if (pattern.thumbnailUrl !== undefined &&
+            !isValidPatternThumbnailUrl(pattern.thumbnailUrl)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-thumbnail-url",
+                message: `${label}: thumbnailUrl must be an http(s) URL or safe relative project path.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+        }
+        const contentFile = resolvePatternCatalogContentFile(pattern);
+        if (!contentFile) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "missing-pattern-content-file",
+                message: `${label}: contentFile or legacy file must point at the pattern PHP file.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+            continue;
+        }
+        if (!isPatternContentFilePath(contentFile)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "invalid-pattern-content-file",
+                message: `${label}: contentFile must be a safe relative project path directly under src/patterns/ or one nested directory under src/patterns/ and end in .php.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+            continue;
+        }
+        if (!options.projectDir) {
+            continue;
+        }
+        const absoluteContentFile = path.join(options.projectDir, contentFile);
+        if (!fs.existsSync(absoluteContentFile)) {
+            diagnostics.push(createPatternCatalogDiagnostic({
+                code: "missing-pattern-content-file",
+                message: `${label}: missing pattern content file ${contentFile}.`,
+                patternSlug: pattern.slug,
+                severity: "error",
+            }));
+            continue;
+        }
+        if (sectionRoleConvention) {
+            let content;
+            try {
+                content = fs.readFileSync(absoluteContentFile, "utf8");
+            }
+            catch (error) {
+                diagnostics.push(createPatternCatalogDiagnostic({
+                    code: "invalid-pattern-content-file",
+                    message: `${label}: failed to read pattern content file ${contentFile}: ${error instanceof Error ? error.message : String(error)}.`,
+                    patternSlug: pattern.slug,
+                    severity: "error",
+                }));
+                continue;
+            }
+            diagnostics.push(...validatePatternContentSectionRoles({
+                content,
+                contentFile,
+                convention: sectionRoleConvention,
+                knownSectionRoles,
+                label,
+                pattern,
+            }));
+        }
+    }
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    return {
+        diagnostics,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Render pattern catalog diagnostics for CLI, sync, and doctor output.
+ *
+ * @param diagnostics Diagnostics returned from {@link validatePatternCatalog}.
+ * @returns Human-readable lines with stable diagnostic codes.
+ */
+export function formatPatternCatalogDiagnostics(diagnostics) {
+    return diagnostics
+        .map((diagnostic) => `- [${diagnostic.code}] ${diagnostic.message}`)
+        .join("\n");
+}

package/dist/runtime/add/persistence-rest-artifacts.d.ts

@@ -0,0 +1,76 @@
+interface PersistenceTemplateVariablesLike {
+    namespace: string;
+    pascalCase: string;
+    restWriteAuthIntent: "authenticated" | "public-write-protected";
+    restWriteAuthMechanism: "public-signed-token" | "rest-nonce";
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncPersistenceRestArtifactsOptions {
+    apiTypesFile: string;
+    outputDir: string;
+    projectDir: string;
+    variables: PersistenceTemplateVariablesLike;
+}
+/**
+ * Build the canonical persistence REST endpoint manifest for scaffold-time
+ * schema, OpenAPI, and client generation.
+ *
+ * @param variables Persistence template naming and auth metadata.
+ * @returns Endpoint manifest covering bootstrap, state read, and state write operations.
+ */
+export declare function buildPersistenceEndpointManifest(variables: PersistenceTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<{
+    readonly "bootstrap-query": {
+        readonly sourceTypeName: `${string}BootstrapQuery`;
+    };
+    readonly "bootstrap-response": {
+        readonly sourceTypeName: `${string}BootstrapResponse`;
+    };
+    readonly "state-query": {
+        readonly sourceTypeName: `${string}StateQuery`;
+    };
+    readonly "state-response": {
+        readonly sourceTypeName: `${string}StateResponse`;
+    };
+    readonly "write-state-request": {
+        readonly sourceTypeName: `${string}WriteStateRequest`;
+    };
+}, readonly [{
+    readonly auth: "public";
+    readonly method: "GET";
+    readonly operationId: `get${string}State`;
+    readonly path: `/${string}/v1/${string}/state`;
+    readonly queryContract: "state-query";
+    readonly responseContract: "state-response";
+    readonly summary: "Read the current persisted state.";
+    readonly tags: readonly [string];
+}, {
+    readonly auth: "authenticated" | "public-write-protected";
+    readonly bodyContract: "write-state-request";
+    readonly method: "POST";
+    readonly operationId: `write${string}State`;
+    readonly path: `/${string}/v1/${string}/state`;
+    readonly responseContract: "state-response";
+    readonly summary: "Write the current persisted state.";
+    readonly tags: readonly [string];
+    readonly wordpressAuth: {
+        readonly mechanism: "public-signed-token" | "rest-nonce";
+    };
+}, {
+    readonly auth: "public";
+    readonly method: "GET";
+    readonly operationId: `get${string}Bootstrap`;
+    readonly path: `/${string}/v1/${string}/bootstrap`;
+    readonly queryContract: "bootstrap-query";
+    readonly responseContract: "bootstrap-response";
+    readonly summary: "Read fresh session bootstrap state for the current viewer.";
+    readonly tags: readonly [string];
+}]>;
+/**
+ * Generate the REST-derived persistence artifacts for a scaffolded block.
+ *
+ * @param options Scaffold output paths plus persistence template variables.
+ * @returns A promise that resolves after schema, OpenAPI, and client files are written.
+ */
+export declare function syncPersistenceRestArtifacts({ apiTypesFile, outputDir, projectDir, variables, }: SyncPersistenceRestArtifactsOptions): Promise<void>;
+export {};

package/dist/runtime/add/persistence-rest-artifacts.js

@@ -0,0 +1,99 @@
+import path from "node:path";
+import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+/**
+ * Build the canonical persistence REST endpoint manifest for scaffold-time
+ * schema, OpenAPI, and client generation.
+ *
+ * @param variables Persistence template naming and auth metadata.
+ * @returns Endpoint manifest covering bootstrap, state read, and state write operations.
+ */
+export function buildPersistenceEndpointManifest(variables) {
+    return defineEndpointManifest({
+        contracts: {
+            "bootstrap-query": {
+                sourceTypeName: `${variables.pascalCase}BootstrapQuery`,
+            },
+            "bootstrap-response": {
+                sourceTypeName: `${variables.pascalCase}BootstrapResponse`,
+            },
+            "state-query": {
+                sourceTypeName: `${variables.pascalCase}StateQuery`,
+            },
+            "state-response": {
+                sourceTypeName: `${variables.pascalCase}StateResponse`,
+            },
+            "write-state-request": {
+                sourceTypeName: `${variables.pascalCase}WriteStateRequest`,
+            },
+        },
+        endpoints: [
+            {
+                auth: "public",
+                method: "GET",
+                operationId: `get${variables.pascalCase}State`,
+                path: `/${variables.namespace}/v1/${variables.slugKebabCase}/state`,
+                queryContract: "state-query",
+                responseContract: "state-response",
+                summary: "Read the current persisted state.",
+                tags: [variables.title],
+            },
+            {
+                auth: variables.restWriteAuthIntent,
+                bodyContract: "write-state-request",
+                method: "POST",
+                operationId: `write${variables.pascalCase}State`,
+                path: `/${variables.namespace}/v1/${variables.slugKebabCase}/state`,
+                responseContract: "state-response",
+                summary: "Write the current persisted state.",
+                tags: [variables.title],
+                wordpressAuth: {
+                    mechanism: variables.restWriteAuthMechanism,
+                },
+            },
+            {
+                auth: "public",
+                method: "GET",
+                operationId: `get${variables.pascalCase}Bootstrap`,
+                path: `/${variables.namespace}/v1/${variables.slugKebabCase}/bootstrap`,
+                queryContract: "bootstrap-query",
+                responseContract: "bootstrap-response",
+                summary: "Read fresh session bootstrap state for the current viewer.",
+                tags: [variables.title],
+            },
+        ],
+        info: {
+            title: `${variables.title} REST API`,
+            version: "1.0.0",
+        },
+    });
+}
+/**
+ * Generate the REST-derived persistence artifacts for a scaffolded block.
+ *
+ * @param options Scaffold output paths plus persistence template variables.
+ * @returns A promise that resolves after schema, OpenAPI, and client files are written.
+ */
+export async function syncPersistenceRestArtifacts({ apiTypesFile, outputDir, projectDir, variables, }) {
+    const manifest = buildPersistenceEndpointManifest(variables);
+    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+        await syncTypeSchemas({
+            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+            projectRoot: projectDir,
+            sourceTypeName: contract.sourceTypeName,
+            typesFile: apiTypesFile,
+        });
+    }
+    await syncRestOpenApi({
+        manifest,
+        openApiFile: path.join(outputDir, "api.openapi.json"),
+        projectRoot: projectDir,
+        typesFile: apiTypesFile,
+    });
+    await syncEndpointClient({
+        clientFile: path.join(outputDir, "api-client.ts"),
+        manifest,
+        projectRoot: projectDir,
+        typesFile: apiTypesFile,
+    });
+}

package/dist/runtime/add/post-meta-binding-fields.d.ts

@@ -0,0 +1,46 @@
+import type { WorkspacePostMetaInventoryEntry } from "../workspace/workspace-inventory-types.js";
+/**
+ * Field metadata extracted from a typed post-meta schema for a generated block
+ * bindings source.
+ *
+ * @property fallbackValue Editor preview value used when live post meta is unavailable.
+ * @property label Human-readable label derived from the schema property name.
+ * @property name Top-level schema property name used as the binding `field` arg.
+ * @property required Whether the field is listed in the schema's required array.
+ * @property schemaType Resolved JSON Schema type used to choose a preview value.
+ */
+export interface PostMetaBindingField {
+    fallbackValue: string;
+    label: string;
+    name: string;
+    required: boolean;
+    schemaType: string;
+}
+/**
+ * Load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Promise resolving to the extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export declare function loadPostMetaBindingFields(projectDir: string, postMeta: WorkspacePostMetaInventoryEntry): Promise<PostMetaBindingField[]>;
+/**
+ * Synchronously load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export declare function loadPostMetaBindingFieldsSync(projectDir: string, postMeta: WorkspacePostMetaInventoryEntry): PostMetaBindingField[];
+/**
+ * Validate and resolve a top-level post-meta binding path.
+ *
+ * @param fields Binding fields extracted from the post-meta schema.
+ * @param postMetaSlug Post-meta contract slug used in diagnostics.
+ * @param metaPath User-provided field path to validate.
+ * @returns The matching binding field.
+ * @throws If the path is empty, nested, or missing from the schema fields.
+ */
+export declare function assertPostMetaBindingPath(fields: readonly PostMetaBindingField[], postMetaSlug: string, metaPath: string): PostMetaBindingField;

package/dist/runtime/add/post-meta-binding-fields.js

@@ -0,0 +1,135 @@
+import path from "node:path";
+import { readJsonFile, readJsonFileSync } from "../shared/json-utils.js";
+const SUPPORTED_SCHEMA_TYPES = new Set([
+    "array",
+    "boolean",
+    "integer",
+    "number",
+    "object",
+    "string",
+]);
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSchemaType(schema) {
+    const type = schema.type;
+    if (typeof type === "string" && SUPPORTED_SCHEMA_TYPES.has(type)) {
+        return type;
+    }
+    if (Array.isArray(type) &&
+        type.every((entry) => typeof entry === "string")) {
+        const nonNullType = type.find((entry) => entry !== "null" && SUPPORTED_SCHEMA_TYPES.has(entry));
+        if (nonNullType) {
+            return nonNullType;
+        }
+    }
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return "string";
+    }
+    return "unknown";
+}
+function resolveFallbackValue(name, schema, schemaType) {
+    const enumValue = Array.isArray(schema.enum)
+        ? schema.enum.find((entry) => typeof entry === "string")
+        : undefined;
+    if (typeof enumValue === "string") {
+        return enumValue;
+    }
+    switch (schemaType) {
+        case "array":
+            return "[]";
+        case "boolean":
+            return "false";
+        case "integer":
+        case "number":
+            return "0";
+        case "object":
+            return "{}";
+        default:
+            return `${name} preview`;
+    }
+}
+function resolveFieldLabel(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function extractPostMetaBindingFields(schema, context) {
+    if (!isJsonRecord(schema) || !isJsonRecord(schema.properties)) {
+        throw new Error(`${context} must expose an object schema with top-level properties before it can back a binding source.`);
+    }
+    const required = Array.isArray(schema.required)
+        ? new Set(schema.required.filter((entry) => typeof entry === "string"))
+        : new Set();
+    const fields = Object.entries(schema.properties).map(([name, propertySchema]) => {
+        const property = isJsonRecord(propertySchema) ? propertySchema : {};
+        const schemaType = resolveSchemaType(property);
+        return {
+            fallbackValue: resolveFallbackValue(name, property, schemaType),
+            label: resolveFieldLabel(name),
+            name,
+            required: required.has(name),
+            schemaType,
+        };
+    });
+    if (fields.length === 0) {
+        throw new Error(`${context} does not expose any top-level properties that can back binding fields.`);
+    }
+    return fields;
+}
+/**
+ * Load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Promise resolving to the extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export async function loadPostMetaBindingFields(projectDir, postMeta) {
+    const schemaPath = path.join(projectDir, postMeta.schemaFile);
+    const schema = await readJsonFile(schemaPath, {
+        context: `post meta schema for ${postMeta.slug}`,
+    });
+    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
+}
+/**
+ * Synchronously load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export function loadPostMetaBindingFieldsSync(projectDir, postMeta) {
+    const schemaPath = path.join(projectDir, postMeta.schemaFile);
+    const schema = readJsonFileSync(schemaPath, {
+        context: `post meta schema for ${postMeta.slug}`,
+    });
+    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
+}
+/**
+ * Validate and resolve a top-level post-meta binding path.
+ *
+ * @param fields Binding fields extracted from the post-meta schema.
+ * @param postMetaSlug Post-meta contract slug used in diagnostics.
+ * @param metaPath User-provided field path to validate.
+ * @returns The matching binding field.
+ * @throws If the path is empty, nested, or missing from the schema fields.
+ */
+export function assertPostMetaBindingPath(fields, postMetaSlug, metaPath) {
+    const trimmed = metaPath.trim();
+    if (!trimmed) {
+        throw new Error("Post meta binding path must include a value.");
+    }
+    if (trimmed.includes(".")) {
+        throw new Error(`Nested post meta path "${trimmed}" for "${postMetaSlug}" is not supported yet. Use one of the top-level fields: ${fields.map((field) => field.name).join(", ")}.`);
+    }
+    const field = fields.find((candidate) => candidate.name === trimmed);
+    if (!field) {
+        throw new Error(`Post meta path "${trimmed}" does not exist in the "${postMetaSlug}" schema. Expected one of: ${fields.map((candidate) => candidate.name).join(", ")}.`);
+    }
+    return field;
+}

package/dist/runtime/add/rest-resource-artifacts.d.ts

@@ -0,0 +1,91 @@
+import type { ManualRestContractAuthId, ManualRestContractHttpMethodId, RestResourceMethodId } from "./cli-add-shared.js";
+interface RestResourceTemplateVariablesLike {
+    namespace: string;
+    pascalCase: string;
+    routePattern?: string;
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncRestResourceArtifactsOptions {
+    clientFile: string;
+    methods: RestResourceMethodId[];
+    outputDir: string;
+    projectDir: string;
+    typesFile: string;
+    validatorsFile: string;
+    variables: RestResourceTemplateVariablesLike;
+}
+interface ManualRestContractTemplateVariablesLike {
+    auth: ManualRestContractAuthId;
+    bodyTypeName?: string;
+    method: ManualRestContractHttpMethodId;
+    namespace: string;
+    pascalCase: string;
+    pathPattern: string;
+    queryTypeName: string;
+    responseTypeName: string;
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncManualRestContractArtifactsOptions {
+    clientFile: string;
+    outputDir: string;
+    projectDir: string;
+    typesFile: string;
+    validatorsFile: string;
+    variables: ManualRestContractTemplateVariablesLike;
+}
+/**
+ * Build the endpoint manifest for a workspace-level REST resource scaffold.
+ *
+ * @param variables Template naming data used for contract names, routes, and OpenAPI info.
+ * @param methods Enabled REST methods for the generated resource.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export declare function buildRestResourceEndpointManifest(variables: RestResourceTemplateVariablesLike, methods: RestResourceMethodId[]): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
+    sourceTypeName: string;
+}>, import("@wp-typia/block-runtime/schema-core").EndpointOpenApiEndpointDefinition[]>;
+/**
+ * Build the endpoint manifest for a type-only manual REST contract. Manual
+ * contracts describe routes owned by another integration without generating PHP
+ * route glue in the workspace.
+ *
+ * @param variables Template naming data used for contract names, route path,
+ * and OpenAPI info.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export declare function buildManualRestContractEndpointManifest(variables: ManualRestContractTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
+    sourceTypeName: string;
+}>, readonly [{
+    readonly wordpressAuth?: {
+        mechanism: "rest-nonce";
+    } | {
+        mechanism: "public-signed-token";
+    } | undefined;
+    readonly method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    readonly operationId: `call${string}ManualRestContract`;
+    readonly path: `/${string}${string}`;
+    readonly queryContract: "query";
+    readonly responseContract: "response";
+    readonly summary: `Call external ${string} REST route.`;
+    readonly tags: readonly [string];
+    readonly bodyContract?: string | undefined;
+    readonly auth: "authenticated" | "public" | "public-write-protected";
+}]>;
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for
+ * a workspace-level REST resource scaffold.
+ *
+ * @param options Resource file paths, enabled methods, and naming variables.
+ * @returns A promise that resolves after every generated REST artifact has been refreshed.
+ */
+export declare function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncRestResourceArtifactsOptions): Promise<void>;
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
+ * type-only manual REST contract.
+ *
+ * @param options Contract file paths and naming variables.
+ * @returns A promise that resolves after every generated artifact has refreshed.
+ */
+export declare function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncManualRestContractArtifactsOptions): Promise<void>;
+export {};