eddev 2.0.0-beta.9 → 2.0.0-beta.91

package/dist/node/project/config.d.ts

@@ -5,124 +5,210 @@ export declare const EDConfigSchema: z.ZodObject<{
     version: z.ZodEffects<z.ZodEnum<["1", "2"]>, "2", "1" | "2">;
     legacyMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     legacyStitches: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    tracking: z.ZodOptional<z.ZodObject<{
-        tagManagerID: z.ZodOptional<z.ZodString>;
-        ga: z.ZodOptional<z.ZodObject<{
-            trackingID: z.ZodOptional<z.ZodString>;
-            version: z.ZodEnum<["3", "4"]>;
-        }, "strip", z.ZodTypeAny, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }>>;
+    trackers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
+        provider: z.ZodLiteral<"ga4">;
+        id: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
+        id: string;
+        provider: "ga4";
     }, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    }>>;
+        id: string;
+        provider: "ga4";
+    }>, z.ZodObject<{
+        provider: z.ZodLiteral<"gtm">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        provider: "gtm";
+    }, {
+        id: string;
+        provider: "gtm";
+    }>]>, "many">>;
     serverless: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         uploads: z.ZodEnum<["proxy", "remote"]>;
         plugins: z.ZodDefault<z.ZodEnum<["proxy", "remote"]>>;
+        admin: z.ZodDefault<z.ZodEnum<["proxy", "hide"]>>;
+        originProtection: z.ZodDefault<z.ZodObject<{
+            requireLogin: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            requireLogin: boolean;
+        }, {
+            requireLogin?: boolean | undefined;
+        }>>;
         themeAssets: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-        apiOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
-        defaultRevalidate: z.ZodOptional<z.ZodNumber>;
-        defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
+        cors: z.ZodOptional<z.ZodObject<{
+            origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            origins?: string[] | undefined;
+        }, {
+            origins?: string[] | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
+        admin: "hide" | "proxy";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }, {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
+        admin?: "hide" | "proxy" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }>;
-    cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        props: z.ZodNumber;
-        queries: z.ZodNumber;
+    cache: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<["always", "ssr-always-fresh"]>;
+            cacheHeaders: z.ZodDefault<z.ZodBoolean>;
+            transients: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        }, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        }>>>;
+        serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            isr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
+        }, "strip", z.ZodTypeAny, {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        }, {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        }>>>;
+        pageDataTTL: z.ZodDefault<z.ZodNumber>;
+        appDataTTL: z.ZodDefault<z.ZodNumber>;
+        queryHooksTTL: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        props: number;
-        queries: number;
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
     }, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }>>>;
     devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
 }, "strip", z.ZodTypeAny, {
     version: "2";
+    cache: Record<string, {
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
+    }>;
     legacyMetadata: boolean;
     legacyStitches: boolean;
     serverless: {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
+        admin: "hide" | "proxy";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
-    devUI: "enabled" | "disabled";
+    devUI: "disabled" | "enabled";
     $schema?: string | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
+    trackers?: ({
+        id: string;
+        provider: "ga4";
+    } | {
+        id: string;
+        provider: "gtm";
+    })[] | undefined;
 }, {
     version: "1" | "2";
     serverless: {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
+        admin?: "hide" | "proxy" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
+    cache?: Record<string, {
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
+    }> | undefined;
     $schema?: string | undefined;
     legacyMetadata?: boolean | undefined;
     legacyStitches?: boolean | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
-    devUI?: "enabled" | "disabled" | undefined;
+    trackers?: ({
+        id: string;
+        provider: "ga4";
+    } | {
+        id: string;
+        provider: "gtm";
+    })[] | undefined;
+    devUI?: "disabled" | "enabled" | undefined;
 }>;
 export type EDConfig = z.infer<typeof EDConfigSchema>;
 export declare class Configurator {

package/dist/node/project/config.js

@@ -15,16 +15,18 @@ export const EDConfigSchema = z.object({
         .default(false)
         .describe("Whether to use legacy comments or exported JSON for block and view metadata"),
     legacyStitches: z.boolean().optional().default(true).describe("Whether this site is using Stitches"),
-    tracking: z
-        .object({
-        tagManagerID: z.string().optional(),
-        ga: z
-            .object({
-            trackingID: z.string().optional(),
-            version: z.enum(["3", "4"]),
-        })
-            .optional(),
-    })
+    trackers: z
+        .array(z.discriminatedUnion("provider", [
+        z.object({
+            provider: z.literal("ga4"),
+            id: z.string().describe("The Google Analytics 4 tracking ID"),
+        }),
+        z.object({
+            provider: z.literal("gtm"),
+            id: z.string().describe("The Google Tag Manager project ID (eg. GTM-XXXXXXX)"),
+        }),
+    ]))
+        .describe("An array of standard tracking codes to embed")
         .optional(),
     serverless: z.object({
         enabled: z.boolean().default(true).describe("Whether to deploy the site as a serverless app"),
@@ -35,25 +37,72 @@ export const EDConfigSchema = z.object({
             .enum(["proxy", "remote"])
             .default("remote")
             .describe("Whether to proxy plugin assets or serve them from the serverless endpoint.\nDefault is `remote`, but `proxy` can be used to hide the CMS origin."),
-        // theme: z.enum(["proxy", "copy", "remote"]),
+        admin: z
+            .enum(["proxy", "hide"])
+            .default("proxy")
+            .describe("How to handle the WordPress admin URLs.\nDefault is `proxy`, which will proxy the admin URLs to the CMS origin. When set to `hide`, all /wp-admin, /wp-json and /wp-login.php URLs will show a 404 page.\nHas no effect in dev mode."),
+        originProtection: z
+            .object({
+            requireLogin: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Enabling this will prevent access to the frontend for non-logged-in users on the CMS origin (eg. Flywheel, WPEngine), but allow access to the serverless frontend (eg. Vercel)."),
+        })
+            .default({}),
         themeAssets: z
             .array(z.string())
             .optional()
             .default(["assets"])
-            .describe('Files to include in a serverless deployment.\nDefault is `["assets"]`'),
-        apiOnly: z.boolean().optional().default(false).describe("Whether to deploy only the API, not the frontend"),
+            .describe('Asset folders to include in a serverless deployment.\nDefault is `["assets"]`'),
         endpoints: z
             .record(z.string(), z.string())
             .describe("A map of WordPress hostnames -> serverless hostnames. You can use `*` as a wildcard for the key.\n\nFor example, `{'cms.ed.studio': 'ed.studio'}` tells the WordPress frontend where it can find any serverless API endpoints."),
-        defaultRevalidate: z.number().optional(),
-        defaultRevalidateQueries: z.number().optional(),
+        cors: z
+            .object({
+            origins: z
+                .array(z.string())
+                .optional()
+                .describe("A list of allowed origins for CORS. Set to ['*'] to allow all. All WordPress hosts are also allowed."),
+        })
+            .optional(),
     }),
     cache: z
-        .record(z.string(), z.object({
-        props: z.number(),
-        queries: z.number(),
+        .record(z.object({
+        wordpress: z
+            .object({
+            strategy: z.enum(["always", "ssr-always-fresh"]),
+            cacheHeaders: z.boolean().default(true).describe("Whether to add caching headers to data requests."),
+            transients: z.boolean().default(true).describe("Whether to cache within transients."),
+        })
+            .optional()
+            .default({ strategy: "always", cacheHeaders: true, transients: true }),
+        serverless: z
+            .object({
+            isr: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to use Incremental Static Regeneration for this origin."),
+            dataCache: z
+                .enum(["in-memory", "kv", "none"])
+                .default("in-memory")
+                .describe("The cache strategy to use for page data."),
+        })
+            .optional()
+            .default({ isr: true, dataCache: "in-memory" }),
+        pageDataTTL: z.number().default(300).describe("The number of seconds to cache page data."),
+        appDataTTL: z.number().default(300).describe("The number of seconds to cache global app data."),
+        queryHooksTTL: z.number().default(300).describe("The number of seconds to cache named GraphQL queries."),
     }))
-        .optional(),
+        .default({
+        "*": {
+            pageDataTTL: 300,
+            appDataTTL: 300,
+            queryHooksTTL: 300,
+        },
+    })
+        .describe("A map of WordPress origin hostnames -> cache settings. Wildcards can be used for each domain."),
     devUI: z.enum(["disabled", "enabled"]).default("enabled"),
 });
 export class Configurator {
@@ -115,7 +164,7 @@ export class Configurator {
             this.config = undefined;
             if (exitOnError) {
                 console.flush();
-                process.exit(0);
+                process.exit(1);
             }
         }
     }

package/dist/node/project/env.d.ts

@@ -5,22 +5,26 @@ export declare const fields: {
     readonly SITE_URL: z.ZodString;
     readonly DEV_HOT_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
     readonly DEV_SERVERLESS_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodString>;
 };
 export declare const ProjectEnvSchema: z.ZodObject<{
     readonly DEBUG_GRAPHQL_URL: z.ZodOptional<z.ZodString>;
     readonly SITE_URL: z.ZodOptional<z.ZodString>;
     readonly DEV_HOT_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
     readonly DEV_SERVERLESS_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: number | undefined;
     DEV_SERVERLESS_PORT?: number | undefined;
+    SITE_API_KEY?: string | undefined;
 }, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: string | undefined;
     DEV_SERVERLESS_PORT?: string | undefined;
+    SITE_API_KEY?: string | undefined;
 }>;
 export type ProjectEnvKey = keyof typeof fields;
 export declare const ProjectEnvUtils: {

package/dist/node/project/env.js

@@ -15,6 +15,7 @@ export const fields = {
     SITE_URL: z.string().url().describe("The URL of the site"),
     DEV_HOT_PORT: portNumber,
     DEV_SERVERLESS_PORT: portNumber,
+    SITE_API_KEY: z.string().optional().describe("The API key for the site, when origin protection is enabled"),
 };
 export const ProjectEnvSchema = z.object(fields).partial();
 export const ProjectEnvUtils = {

package/dist/node/project/manifest/block-manifest.js

@@ -134,6 +134,7 @@ function readBlockDataAsJSONExport(file, contents) {
     result.frontendMode = userData.frontendMode;
     if (userData.postMetaBlock) {
         result.postMetaBlock = {
+            postTypes: userData.postMetaBlock.postTypes,
             fieldName: userData.postMetaBlock.fieldName,
         };
         result.types = userData.postMetaBlock.postTypes;

package/dist/node/project/manifest/manifest.d.ts

@@ -8,6 +8,7 @@ type ManifestEntry<TEntryData> = {
 type ManifestGeneratorArgs<TEntryData, TManifest> = {
     baseDir: string;
     pattern: string | string[];
+    ignore?: string[];
     watch: boolean;
     loadValue: (path: string, key: string) => Promise<TEntryData>;
     getKey: (path: string) => string | null;

package/dist/node/project/manifest/manifest.js

@@ -31,20 +31,24 @@ export function createManifestGenerator(args) {
                 }
             };
             if (args.watch) {
-                const disposer = await watchFileTree(args.pattern, (fileList, event) => {
-                    files = fileList;
-                    cache = new Map();
-                    if (args.onFileChange)
-                        fileList.forEach(args.onFileChange);
-                    update();
-                    if (event) {
-                        events.push(event);
-                    }
+                const disposer = await watchFileTree({
+                    pattern: args.pattern,
+                    ignore: args.ignore,
+                    callback: (fileList, event) => {
+                        files = fileList;
+                        cache = new Map();
+                        if (args.onFileChange)
+                            fileList.forEach(args.onFileChange);
+                        update();
+                        if (event) {
+                            events.push(event);
+                        }
+                    },
                 });
                 disposers.push(disposer);
             }
             else {
-                files = await getFileTree(args.pattern);
+                files = await getFileTree({ pattern: args.pattern, ignore: args.ignore });
                 update();
             }
         });

package/dist/node/project/manifest/routes-manifest.d.ts

@@ -0,0 +1,20 @@
+import { Project } from "../project.js";
+export type RouteManifest = {
+    routes: Record<string, RouteInfo>;
+    contextFileName: string | null;
+    validationMessages: {
+        fieldKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+    bases: string[];
+};
+type RouteInfo = {
+    kind: "context" | "route";
+    fileName: string;
+    prefix?: string;
+    error?: string;
+};
+export type RouteManifestGenerator = ReturnType<typeof loadRouteManifest>;
+export declare function loadRouteManifest(project: Project): import("./manifest.js").ManifestGenerator<RouteInfo, RouteManifest>;
+export {};

package/dist/node/project/manifest/routes-manifest.js

@@ -0,0 +1,74 @@
+import { cliMode } from "../../cli/cli-mode.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadRouteManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: ["server/routes/**/*.{ts,tsx}", "server/_context.{ts,tsx}"],
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                routes: {},
+                contextFileName: null,
+                validationMessages: [],
+                bases: [],
+            };
+            const bases = new Set();
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                if (entry.value.kind === "context") {
+                    result.contextFileName = entry.value.fileName;
+                }
+                else if (entry.value.kind === "route") {
+                    const { error: initialError } = entry.value;
+                    const prefix = entry.value.prefix;
+                    result.routes[key] = entry.value;
+                    if (prefix) {
+                        let shouldAdd = true;
+                        bases.forEach((base) => {
+                            if (base.startsWith(prefix)) {
+                                bases.delete(base);
+                            }
+                            else if (prefix.startsWith(base)) {
+                                shouldAdd = false;
+                                return;
+                            }
+                        });
+                        if (shouldAdd) {
+                            bases.add(entry.value.prefix);
+                        }
+                    }
+                    if (initialError) {
+                        result.validationMessages.push({
+                            fieldKey: key,
+                            message: initialError,
+                            severity: "error",
+                        });
+                        return;
+                    }
+                }
+            });
+            result.bases = [...bases].sort().map((base) => "/" + base.replace(/\./g, "/"));
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx?$/, "").replace(/^server\/routes\//, "");
+        },
+        async loadValue(fileName, key) {
+            if (fileName.startsWith("server/_context.")) {
+                return {
+                    kind: "context",
+                    fileName,
+                };
+            }
+            return {
+                kind: "route",
+                prefix: key.replace("/index", "").replace(/\//, "."),
+                fileName,
+            };
+        },
+    });
+}

package/dist/node/project/manifest/view-manifest.js

@@ -1,9 +1,9 @@
 import { basename } from "node:path";
 import { cliMode } from "../../cli/cli-mode.js";
 import { ViewMetaSchema } from "../../types/view-type.js";
-import { metaExtractor } from "../../utils/ts-export-extractor.js";
 import { formatZodError } from "../../utils/format-zod-error.js";
 import { fs } from "../../utils/fs.js";
+import { metaExtractor } from "../../utils/ts-export-extractor.js";
 import { createManifestGenerator } from "./manifest.js";
 export function loadViewManifest(project) {
     return createManifestGenerator({

package/dist/node/project/project.d.ts

@@ -1,7 +1,8 @@
 import { EDConfig } from "./config.js";
 import { BlockManifestGenerator } from "./manifest/block-manifest.js";
-import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { FieldManifestGenerator } from "./manifest/field-manifest.js";
+import { RouteManifestGenerator } from "./manifest/routes-manifest.js";
+import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { WidgetManifestGenerator } from "./manifest/widget-manifest.js";
 export declare const projectLog: import("../utils/stateful-log.js").StatefulLog<Project>;
 type ProjectArgs = {
@@ -24,9 +25,16 @@ export declare class Project {
     views: ViewManifestGenerator;
     fields: FieldManifestGenerator;
     widgets: WidgetManifestGenerator;
+    serverRoutes: RouteManifestGenerator;
     private wp;
     reportPluginCompatibility: boolean;
     private constructor();
+    verifyOriginAccess(): Promise<{
+        success: true;
+    } | {
+        success: false;
+        message: string;
+    }>;
     private load;
     reportProjectInfo(): string;
     getWordpressInfo(): Promise<{