@wp-playground/blueprints 2.0.21 → 3.0.1

package/lib/v2/wep-1-blueprint-v2-schema/appendix-A-blueprint-v2-schema.d.ts

@@ -0,0 +1,1400 @@
+import type { DataSources } from './appendix-B-data-sources';
+export declare namespace V2Schema {
+    export type BlueprintV2 = {
+        /**
+         * Not a generic 'number' type – this schema is specifically for
+         * Blueprints v2. Version 1 had no "version" field and versions 3, 4,
+         * 5, etc will be different from version 2.
+         */
+        version: 2;
+        /**
+         * JSON Schema URL.
+         */
+        $schema?: DataSources.URLReference | DataSources.ExecutionContextPath;
+        blueprintMeta?: {
+            name?: string;
+            description?: string;
+            moreInfo?: string;
+            version?: string;
+            authors?: string[];
+            homepage?: DataSources.URLReference;
+            donateLink?: DataSources.URLReference;
+            tags?: string[];
+            license?: LicenseKeyword | string;
+        };
+        /**
+         * Divergence from Blueprints v1:
+         *
+         * There are no `landingPage` or `login` top-level properties.
+         * Instead, Blueprint v2 introduces a dedicated top-level `applicationOptions` property
+         * for declaring options or opinions for different application contexts.
+         *
+         * To keep Blueprints portable and focused on site creation, this specification
+         * only allows two Playground-specific options. Other environments cannot declare
+         * additional options. Future versions of this specification may allow additional
+         * options – they will be discussed on a case-by-case basis.
+         */
+        applicationOptions?: {
+            /**
+             * Options for the WordPress Playground.
+             */
+            'wordpress-playground': {
+                /**
+                 * The first page the user is redirected to once the Playground is loaded and
+                 * the Blueprint is executed.
+                 *
+                 * @default "/wp-admin"
+                 */
+                landingPage?: string;
+                /**
+                 * Whether to log the user in after the Blueprint is executed. If true,
+                 * the user is logged in as "admin".
+                 *
+                 * @default false
+                 */
+                login?: boolean | {
+                    username: string;
+                    password: string;
+                };
+                /**
+                 * Whether to allow the site to access the network.
+                 *
+                 * @default false
+                 */
+                networkAccess?: boolean;
+            };
+        };
+        /**
+         * SITE OPTIONS {{{
+         *
+         * There are no "nice" top-level shortcuts such as `siteTitle` to implicitly set "popular"
+         * site options. All the options must be explicitly declared via the `siteOptions` property.
+         * Why? Two reasons:
+         *
+         * * No need to ask developers to learn a new set of identifiers.
+         * * It's unclear which site title should win if the Blueprint declares both
+         *   `siteTitle` and `siteOptions.blogname`.
+         *
+         * The tao of Python says: Explicit is better than implicit. Let's stick with that.
+         */
+        /**
+         * Sets the WPLANG constant and downloads any missing translations for WordPress
+         * core and all the installed plugins and themes. If you need a fine-grained
+         * control over the translations, use imperative steps in the `additionalStepsAfterExecution`
+         * array.
+         *
+         * @default "en_US"
+         */
+        siteLanguage?: string;
+        /**
+         * Site options. In WordPress, the values are PHP-serializable, but Blueprints are
+         * intentionally restricted to an even stricter subset of those, that are JSON-serializable.
+         * This is to prevent passing JavaScript Date objects and similar.
+         *
+         * The runner **MUST** use the WordPress `update_option` function to store the
+         * siteOptions values defined in this property as WordPress options. Lists and
+         * objects are passed to `update_option` as PHP arrays.
+         *
+         * Site options example:
+         *
+         * ```json
+         * {
+         *     "blogname": "Adam's Movies",
+         *     "timezone": "Poland/Warsaw",
+         *     "gutenberg-experiments": {
+         * 			'gutenberg-custom-dataviews': true,
+         * 			'gutenberg-new-posts-dashboard': true,
+         * 			'gutenberg-quick-edit-dataviews': true
+         * 		}
+         * }
+         * ```
+         */
+        siteOptions?: {
+            /**
+             * Site title.
+             *
+             * Example: "Adam's Movies"
+             * @default "My WordPress Site"
+             */
+            blogname?: string;
+            /**
+             * Example: "Poland/Warsaw"
+             * @default "UTC"
+             */
+            timezone_string?: string;
+            /**
+             * Site permalink structure. If present and different from the current permalink structure,
+             * the Blueprint runner will run `$wp_rewrite->flush_rules();`. If you only want to set this
+             * option without flushing the rules, use an explicit `additionalStepsAfterExecution` step.
+             *
+             * Example: "/%year%/%monthnum%/%postname%/" or false for no pretty permalinks.
+             * @default "/%postname%/"
+             */
+            permalink_structure?: string | false;
+        } & Record<Exclude<string, 'siteUrl'>, JsonValue>;
+        /**
+         * }}}
+         */
+        /**
+         * Constants to define in the wp-config.php file.
+         *
+         * The runner may overwrite the define() calls in the wp-config.php file
+         * on the target site. It assumes the wp-config.php file at the Blueprint
+         * Execution Target is writable.
+         *
+         * @see https://github.com/WordPress/blueprints-library/issues/118
+         */
+        constants?: WordPressConstants;
+        /**
+         * WordPress version to install.
+         *
+         * When we're setting up the entire site, this will be used to resolve the
+         * installed WordPress version. The latest version matching the constraint
+         * will be chosen.
+         *
+         * When we're applying this Blueprint to an existing site, this will be used
+         * as an integrity check to verify that the currently installed version of
+         * WordPress installed on the target site matches the constraint.
+         *
+         * @default "latest".
+         */
+        wordpressVersion?: DataSources.WordPressVersion | DataSources.DataReference | {
+            min: DataSources.WordPressVersion;
+            max?: DataSources.WordPressVersion;
+            /**
+             * @default "latest"
+             */
+            preferred?: DataSources.WordPressVersion;
+        };
+        /**
+         * The PHP version required for this Blueprint to work.
+         *
+         * In runtimes where we set up the runtime, such as Playground and wp-env, the
+         * runner will choose a version compatible with this constraint.
+         *
+         * In other environments, this is used for validation. The Blueprint engine will
+         * throw an error if the currently running PHP version doesn't match this constraint.
+         *
+         * @default "8.0". Changing the default value will bump the Blueprint version.
+         *
+         * @see https://github.com/WordPress/blueprints-library/issues/47
+         */
+        phpVersion?: DataSources.PHPVersion | {
+            min?: DataSources.PHPVersion;
+            recommended?: DataSources.PHPVersion;
+            max?: DataSources.PHPVersion;
+        };
+        /**
+         * The theme to install and also activate.
+         *
+         * > Why not support an `active` property in the `themes` array?
+         *
+         * Because an `"active"` property would have to default to `false` for themes while it
+         * defaults to `true` for plugins. That's error-prone and confusing.
+         *
+         * @example `"activeTheme": "stylish-press-theme"`
+         * @example `"activeTheme": "adventurer@4.6.0"`
+         * @example
+         * ```json
+         * "activeTheme": {
+         *     "source": "https://github.com/richtabor/kanso/archive/refs/heads/main.zip",
+         *     "id": "kanso"
+         * }
+         * ```
+         */
+        activeTheme?: ThemeDefinition;
+        /**
+         * Installed themes to install without activating them.
+         *
+         * Example:
+         *
+         * ```json
+         * themes: [
+         *     "stylish-press-theme",
+         *     "adventurer@4.6.0",
+         *     {
+         *         "source": "https://github.com/richtabor/kanso/archive/refs/heads/main.zip",
+         *         "id": "kanso"
+         *     }
+         * ]
+         * ```
+         */
+        themes?: ThemeDefinition[];
+        /**
+         * A list of plugins to install and activate.
+         *
+         * Example:
+         *
+         * ```json
+         * plugins: [
+         *     "jetpack",
+         *     "akismet@6.4.3",
+         *     "./query-monitor.php",
+         *     "./code-block.zip",
+         *     {
+         *         "source": "https://github.com/woocommerce/woocommerce/archive/refs/heads/6.4.3.zip",
+         *         "active": false
+         *     }
+         * ]
+         */
+        plugins?: PluginDefinition[];
+        /**
+         * A list of mu-plugins to install.
+         *
+         * Example:
+         *
+         * ```json
+         * muPlugins: [
+         *     {
+         *         "file": {
+         *             "filename": "addFilter-0.php",
+         *             "content": "<?php add_action( 'requests-requests.before_request', function( &$url ) {\n$url = 'https://playground.wordpress.net/cors-proxy.php?' . $url;\n} );"
+         *         }
+         *     }
+         * ]
+         * ```
+         */
+        muPlugins?: Array<DataSources.DataReference>;
+        /**
+         * Very basic schema for defining custom post types.
+         *
+         * IMPORTANT: Using this property requires an explicit inclusion of the
+         * `secure-custom-fields` plugin. If it's missing, the Blueprint runner will
+         * throw an error.
+         *
+         * See https://github.com/WordPress/blueprints-library/issues/32 for more context.
+         */
+        postTypes?: Record<PostTypeKey, PostType | DataSources.ExecutionContextPath>;
+        /**
+         * A list of fonts to register in the site's Font Library.
+         *
+         * Example:
+         *
+         * ```json
+         * fonts: {
+         *     "open-sans": "https://example.com/fonts/open-sans.woff2",
+         *     "roboto": "./wp-content/fonts/roboto.woff2"
+         * }
+         * ```
+         *
+         * Or using the full font collection schema:
+         *
+         * ```json
+         * fonts: {
+         *     "my-collection": {
+         *         "font_families": [
+         *             {
+         *                 "font_family_settings": {
+         *                     "name": "Open Sans",
+         *                     "slug": "open-sans",
+         *                     "fontFamily": "Open Sans",
+         *                     "preview": "https://example.com/previews/open-sans.png",
+         *                     "fontFace": [
+         *                         {
+         *                             "fontFamily": "Open Sans",
+         *                             "fontWeight": "400",
+         *                             "fontStyle": "normal",
+         *                             "src": "./wp-content/fonts/open-sans-regular.woff2"
+         *                         }
+         *                     ]
+         *                 },
+         *                 "categories": ["sans-serif"]
+         *             }
+         *         ]
+         *     }
+         * }
+         * ```
+         */
+        fonts?: Record<string, DataSources.DataReference | FontCollection>;
+        /**
+         * A list of media files to upload to the WordPress Media Library – in formats
+         * supported by the WordPress Media Library.
+         *
+         * Example:
+         *
+         * ```json
+         * media: [
+         *     "https://example.com/images/hero.jpg",
+         *     "./wp-content/uploads/2024/01/logo.png",
+         *     {
+         *         "source": "https://example.com/videos/intro.mp4",
+         *         "title": "Introduction Video",
+         *         "description": "A brief introduction to our company",
+         *         "alt": "Company introduction video"
+         *     },
+         *     {
+         *         "source": "./wp-content/uploads/2024/01/brochure.pdf",
+         *         "title": "Product Brochure",
+         *         "description": "Detailed information about our products"
+         *     }
+         * ]
+         * ```
+         *
+         */
+        media?: Array<MediaDefinition>;
+        content?: Array<ContentDefinition>;
+        users?: Array<{
+            username: string;
+            email: string;
+            role: string;
+            meta: Record<string, string>;
+        }>;
+        roles?: Array<{
+            name: string;
+            capabilities: Record<string, string>;
+        }>;
+        additionalStepsAfterExecution?: Array<Step>;
+    };
+    type LicenseKeyword = 'AFL-3.0' | 'Apache-2.0' | 'Artistic-2.0' | 'BSL-1.0' | 'BSD-2-Clause' | 'BSD-3-Clause' | 'BSD-3-Clause-Clear' | 'BSD-4-Clause' | '0BSD' | 'CC' | 'CC0-1.0' | 'CC-BY-4.0' | 'CC-BY-SA-4.0' | 'WTFPL' | 'ECL-2.0' | 'EPL-1.0' | 'EPL-2.0' | 'EUPL-1.1' | 'AGPL-3.0' | 'GPL' | 'GPL-2.0' | 'GPL-3.0' | 'LGPL' | 'LGPL-2.1' | 'LGPL-3.0' | 'ISC' | 'LPPL-1.3c' | 'MS-PL' | 'MIT' | 'MPL-2.0' | 'OSL-3.0' | 'PostgreSQL' | 'OFL-1.1' | 'NCSA' | 'Unlicense' | 'Zlib';
+    type URLMappingConfig = {
+        /**
+         * Whether to rewrite the hrefs in the remote site's content URLs in the WXR file
+         * from the remote site domain to the current site domain's (and path etc).
+         *
+         * Possible values:
+         *
+         * * "rewrite" – Rewrite the hrefs to the current site domain's (and path etc).
+         * * "preserve" – Preserve the hrefs as they are.
+         *
+         * @default "rewrite".
+         */
+        urlsMode?: 'rewrite' | 'preserve';
+        /**
+         * A mapping of base URLs to rewrite.
+         */
+        urlsMap?: Record<DataSources.URLReference, DataSources.URLReference>;
+    };
+    type ContentDefinition = ({
+        type: 'mysql-dump';
+        source: DataSources.DataReference | DataSources.DataReference[];
+    } & URLMappingConfig) | ({
+        type: 'posts';
+        source: DataSources.DataReference | DataSources.DataReference[] | WordPressPost | WordPressPost[];
+    } & URLMappingConfig)
+    /**
+     * WXR files to import.
+     *
+     * Example:
+     *
+     * ```json
+     * content: [
+     *     {
+     *         "type": "wxr",
+     *         "https://raw.githubusercontent.com/wordpress/blueprints/trunk/blueprints/stylish-press/woo-products.wxr"
+     *     },
+     *     {
+     *         "type": "wxr",
+     *         "url": "https://raw.githubusercontent.com/wordpress/blueprints/trunk/blueprints/stylish-press/site-content.wxr",
+     *         "rewriteUrls": true,
+     *         "fetchStaticAssets": false,
+     *         "users": false,
+     *         "comments": false,
+     *     }
+     * ]
+     * ```
+     */
+     | ({
+        type: 'wxr';
+        source: DataSources.DataReference;
+        /**
+         * Static assets handling.
+         *
+         * Possible values:
+         *
+         * * "fetch" – Fetch the static assets and save them to the local filesystem.
+         * * "hotlink" – Hotlink the static assets from the remote site.
+         *
+         * @default "fetch".
+         */
+        staticAssets?: 'fetch' | 'hotlink';
+        /**
+         * How to handle authors that don't exist on the current site.
+         *
+         * Possible values:
+         *
+         * * "create" – Create a new author.
+         * * "default-author" – Use the default author.
+         * * "map" – Map the author to an existing author on the current site.
+         *
+         * @default "create".
+         */
+        authorsMode?: 'create' | 'default-author' | 'map';
+        /**
+         * The default author to use when `mode` is "default-author".
+         *
+         * @default "admin".
+         */
+        defaultAuthorUsername?: string;
+        /**
+         * Map post authors from the remote site to the current site.
+         *
+         * When not provided, the importer will attempt to match the authors by
+         * username, email, or name.
+         *
+         * Required when `authorsMode` is "map".
+         *
+         * @default undefined.
+         */
+        authorsMap?: Record<RemoteUsername, LocalUsername>;
+        /**
+         * Whether to import users from the remote site.
+         *
+         * @default false.
+         */
+        importUsers?: boolean;
+        /**
+         * Whether to import comments from the remote site.
+         *
+         * @default false.
+         */
+        importComments?: boolean;
+        /**
+         * Whether to import site settings from the remote site.
+         *
+         * @default false.
+         */
+        importSiteOptions?: boolean;
+    } & URLMappingConfig);
+    type MediaDefinition = DataSources.DataReference | {
+        source: DataSources.DataReference;
+        title?: string;
+        description?: string;
+        alt?: string;
+        caption?: string;
+    };
+    type PluginDefinition = DataSources.DataReference | DataSources.PluginDirectoryReference | PluginObjectDefinition;
+    type PluginObjectDefinition = {
+        source: DataSources.DataReference | DataSources.PluginDirectoryReference;
+        /**
+         * Whether to activate the plugin.
+         *
+         * @default true.
+         */
+        active?: boolean;
+        /**
+         * Parameters to pass to the plugin during activation.
+         *
+         * These options are stored in a site option that the plugin can access
+         * during its activation hook. The option name is:
+         *
+         * ```php
+         * 'blueprint_activation_' . plugin_basename( __FILE__ )
+         * ```
+         *
+         * This ensures uniqueness even when multiple versions of the same plugin exist.
+         * This is similar to how the `register_activation_hook` function requires the
+         * plugin file path as its first argument.
+         *
+         * The Blueprint runner will remove the option after activating the plugin.
+         *
+         * Example:
+         *
+         * In the Blueprint:
+         * ```json
+         * {
+         *     "source": "woocommerce",
+         *     "activationOptions": {
+         *         "storeCity": "Wrocław",
+         *         "storeCountry": "Poland",
+         *         "storePostalCode": "53-607"
+         *     }
+         * }
+         * ```
+         *
+         * In the plugin's activation hook:
+         *
+         * ```php
+         * register_activation_hook( __FILE__, function( $network_wide ) {
+         *     // Get the activation options from the transient
+         *     $option_name = 'blueprint_activation_' . plugin_basename( __FILE__ );
+         *     $blueprint_activation_options = get_option( $option_name ) ?? [];
+         *
+         *     if ( $blueprint_activation_options ) {
+         *         $store_city = $blueprint_activation_options['storeCity'] ?? '';
+         *         $store_country = $blueprint_activation_options['storeCountry'] ?? '';
+         *         $store_postal_code = $blueprint_activation_options['storePostalCode'] ?? '';
+         *
+         *         // ...do something with the options...
+         *     }
+         *
+         *     // Continue with normal activation...
+         * } );
+         * ```
+         */
+        activationOptions?: Record<string, JsonValue>;
+        /**
+         * An explicit directory name within wp-content/plugins to install the plugin at.
+         * If not provided, it will be inferred from the plugin source.
+         */
+        targetDirectoryName?: string;
+        /**
+         * Sometimes it's fine when a plugin fails to install.
+         *
+         * Use-case:
+         *   Compatibility testing. A Blueprint may install WordPress nightly with
+         *   a number of plugins to test. Some of those plugins may not yet be compatible
+         *   with the latest version of WordPress. This is something to take not of,
+         *   but not a strong reason to fail the entire Blueprint installation.
+         *
+         * @see https://github.com/WordPress/wordpress-playground/issues/600
+         * @default "throw"
+         */
+        onError?: 'skip-plugin' | 'throw';
+        /**
+         * Human-readable name of the plugin for the progress bar.
+         *
+         * For example, with the following Blueprint:
+         *
+         * ```json
+         * {
+         *     "plugins": [
+         *         {
+         *             "source": "https://github.com/Automattic/jetpack/archive/refs/heads/beta.zip",
+         *             "humanReadableName": "Jetpack Beta"
+         *         }
+         *     ]
+         * }
+         * ```
+         *
+         * The progress bar will show "Installing Jetpack Beta plugin" instead of
+         * "Installing https://github.com/Automattic/jetpack/archive/refs/heads/beta.zip".
+         */
+        humanReadableName?: string;
+    };
+    type ThemeDefinition = DataSources.ThemeDirectoryReference | DataSources.DataReference | ThemeObjectDefinition;
+    type ThemeObjectDefinition = {
+        source: DataSources.ThemeDirectoryReference | DataSources.DataReference;
+        /**
+         * Whether to import the theme's starter content after installing it.
+         */
+        importStarterContent?: boolean;
+        /**
+         * An explicit directory name within wp-content/themes to install the theme at.
+         * If not provided, it will be inferred from the theme source.
+         */
+        targetDirectoryName?: string;
+        /**
+         * Human-readable name of the theme for the progress bar.
+         *
+         * For example, with the following Blueprint:
+         *
+         * ```json
+         * {
+         *     "themes": [
+         *         {
+         *             "source": "https://github.com/Automattic/adventurer/archive/refs/heads/beta.zip",
+         *             "humanReadableName": "Adventurer"
+         *         }
+         *     ]
+         * }
+         * ```
+         *
+         * The progress bar will show "Installing Adventurer theme" instead of
+         * "Installing https://github.com/Automattic/adventurer/archive/refs/heads/beta.zip".
+         */
+        humanReadableName?: string;
+    };
+    type RemoteUsername = 'string';
+    type LocalUsername = 'string';
+    /**
+     * WordPress register_post_type() arguments representation. {{{
+     *
+     * The inline docstrings are copied from the WordPress code reference.
+     *
+     * @see https://developer.wordpress.org/reference/functions/register_post_type/
+     */
+    /**
+     * Post type key. Must not exceed 20 characters and may only
+     * contain lowercase alphanumeric characters, dashes, and underscores.
+     */
+    type PostTypeKey = string;
+    type Block = [string, Record<string, JsonValue>];
+    type PostType = {
+        /**
+         * Name of the post type shown in the menu. Usually plural.
+         * Default is value of $labels['name'].
+         */
+        label?: string;
+        /**
+         * An array of labels for this post type.
+         * If not set, post labels are inherited for non-hierarchical types
+         * and page labels for hierarchical ones
+         *
+         * The labels documented for WordPress 6.8 are listed below,
+         * and this type also supports an arbitrary set of labels to
+         * support future WordPress releases.
+         *
+         * @see https://developer.wordpress.org/reference/functions/get_post_type_labels/
+         */
+        labels?: {
+            /**
+             * General name for the post type, usually plural.
+             * Default is 'Posts' / 'Pages'.
+             */
+            name?: string;
+            /**
+             * Name for one object of this post type.
+             * Default is 'Post' / 'Page'.
+             */
+            singular_name?: string;
+            /**
+             * Label for adding a new item.
+             * Default is 'Add New' / 'Add New'.
+             */
+            add_new?: string;
+            /**
+             * Label for adding a new singular item.
+             * Default is 'Add New Post' / 'Add New Page'.
+             */
+            add_new_item?: string;
+            /**
+             * Label for editing a singular item.
+             * Default is 'Edit Post' / 'Edit Page'.
+             */
+            edit_item?: string;
+            /**
+             * Label for the new item page title.
+             * Default is 'New Post' / 'New Page'.
+             */
+            new_item?: string;
+            /**
+             * Label for viewing a singular item.
+             * Default is 'View Post' / 'View Page'.
+             */
+            view_item?: string;
+            /**
+             * Label for viewing post type archives.
+             * Default is 'View Posts' / 'View Pages'.
+             */
+            view_items?: string;
+            /**
+             * Label for searching plural items.
+             * Default is 'Search Posts' / 'Search Pages'.
+             */
+            search_items?: string;
+            /**
+             * Label used when no items are found.
+             * Default is 'No posts found' / 'No pages found'.
+             */
+            not_found?: string;
+            /**
+             * Label used when no items are in the Trash.
+             * Default is 'No posts found in Trash' / 'No pages found in Trash'.
+             */
+            not_found_in_trash?: string;
+            /**
+             * Label used to prefix parents of hierarchical items.
+             * Default is 'Parent Page:'.
+             */
+            parent_item_colon?: string;
+            /**
+             * Label to signify all items in a submenu link.
+             * Default is 'All Posts' / 'All Pages'.
+             */
+            all_items?: string;
+            /**
+             * Label for archives in nav menus.
+             * Default is 'Post Archives' / 'Page Archives'.
+             */
+            archives?: string;
+            /**
+             * Label for the attributes meta box.
+             * Default is 'Post Attributes' / 'Page Attributes'.
+             */
+            attributes?: string;
+            /**
+             * Label for the media frame button.
+             * Default is 'Insert into post' / 'Insert into page'.
+             */
+            insert_into_item?: string;
+            /**
+             * Label for the media frame filter.
+             * Default is 'Uploaded to this post' / 'Uploaded to this page'.
+             */
+            uploaded_to_this_item?: string;
+            /**
+             * Label for the featured image meta box title.
+             * Default is 'Featured image'.
+             */
+            featured_image?: string;
+            /**
+             * Label for setting the featured image.
+             * Default is 'Set featured image'.
+             */
+            set_featured_image?: string;
+            /**
+             * Label for removing the featured image.
+             * Default is 'Remove featured image'.
+             */
+            remove_featured_image?: string;
+            /**
+             * Label in the media frame for using a featured image.
+             * Default is 'Use as featured image'.
+             */
+            use_featured_image?: string;
+            /**
+             * Label for the menu name.
+             * Default is the same as name.
+             */
+            menu_name?: string;
+            /**
+             * Label for the table views hidden heading.
+             * Default is 'Filter posts list' / 'Filter pages list'.
+             */
+            filter_items_list?: string;
+            /**
+             * Label for the date filter in list tables.
+             * Default is 'Filter by date'.
+             */
+            filter_by_date?: string;
+            /**
+             * Label for the table pagination hidden heading.
+             * Default is 'Posts list navigation' / 'Pages list navigation'.
+             */
+            items_list_navigation?: string;
+            /**
+             * Label for the table hidden heading.
+             * Default is 'Posts list' / 'Pages list'.
+             */
+            items_list?: string;
+            /**
+             * Label used when an item is published.
+             * Default is 'Post published.' / 'Page published.'
+             */
+            item_published?: string;
+            /**
+             * Label used when an item is published with private visibility.
+             * Default is 'Post published privately.' / 'Page published privately.'
+             */
+            item_published_privately?: string;
+            /**
+             * Label used when an item is switched to a draft.
+             * Default is 'Post reverted to draft.' / 'Page reverted to draft.'
+             */
+            item_reverted_to_draft?: string;
+            /**
+             * Label used when an item is moved to Trash.
+             * Default is 'Post trashed.' / 'Page trashed.'
+             */
+            item_trashed?: string;
+            /**
+             * Label used when an item is scheduled for publishing.
+             * Default is 'Post scheduled.' / 'Page scheduled.'
+             */
+            item_scheduled?: string;
+            /**
+             * Label used when an item is updated.
+             * Default is 'Post updated.' / 'Page updated.'
+             */
+            item_updated?: string;
+            /**
+             * Title for a navigation link block variation.
+             * Default is 'Post Link' / 'Page Link'.
+             */
+            item_link?: string;
+            /**
+             * Description for a navigation link block variation.
+             * Default is 'A link to a post.' / 'A link to a page.'
+             */
+            item_link_description?: string;
+        } & Record<string, string>;
+        /**
+         * A short descriptive summary of what the post type is.
+         */
+        description?: string;
+        /**
+         * Whether a post type is intended for use publicly either via the admin interface or by front-end users.
+         * While the default settings of $exclude_from_search, $publicly_queryable, $show_ui, and $show_in_nav_menus
+         * are inherited from $public, each does not rely on this relationship and controls a very specific intention.
+         * Default false.
+         */
+        public?: boolean;
+        /**
+         * Whether the post type is hierarchical (e.g. page).
+         * Default false.
+         */
+        hierarchical?: boolean;
+        /**
+         * Whether to exclude posts with this post type from front end search results.
+         * Default is the opposite value of $public.
+         */
+        exclude_from_search?: boolean;
+        /**
+         * Whether queries can be performed on the front end for the post type as part of parse_request().
+         * Endpoints would include:
+         * * ?post_type={post_type_key}
+         * * ?{post_type_key}={single_post_slug}
+         * * ?{post_type_query_var}={single_post_slug}
+         * If not set, the default is inherited from $public.
+         */
+        publicly_queryable?: boolean;
+        /**
+         * Whether to generate and allow a UI for managing this post type in the admin.
+         * Default is value of $public.
+         */
+        show_ui?: boolean;
+        /**
+         * Where to show the post type in the admin menu. To work, $show_ui must be true.
+         * If true, the post type is shown in its own top level menu.
+         * If false, no menu is shown.
+         * If a string of an existing top level menu ('tools.php' or 'edit.php?post_type=page', for example),
+         * the post type will be placed as a sub-menu of that.
+         * Default is value of $show_ui.
+         */
+        show_in_menu?: boolean | string;
+        /**
+         * Makes this post type available via the admin bar.
+         * Default is value of $show_in_menu.
+         */
+        show_in_admin_bar?: boolean;
+        /**
+         * Makes this post type available for selection in navigation menus.
+         * Default is value of $public.
+         */
+        show_in_nav_menus?: boolean;
+        /**
+         * Whether to include the post type in the REST API.
+         * Set this to true for the post type to be available in the block editor.
+         */
+        show_in_rest?: boolean;
+        /**
+         * To change the base URL of REST API route.
+         * Default is $post_type.
+         */
+        rest_base?: string;
+        /**
+         * To change the namespace URL of REST API route.
+         * Default is wp/v2.
+         */
+        rest_namespace?: string;
+        /**
+         * REST API controller class name.
+         * Default is 'WP_REST_Posts_Controller'.
+         */
+        rest_controller_class?: string;
+        /**
+         * The URL to the icon to be used for this menu.
+         * Pass a base64-encoded SVG using a data URI, which will be colored to match the color scheme —
+         * this should begin with 'data:image/svg+xml;base64,'.
+         * Pass the name of a Dashicons helper class to use a font icon, e.g. 'dashicons-chart-pie'.
+         * Pass 'none' to leave div.wp-menu-image empty so an icon can be added via CSS.
+         * Defaults to use the posts icon.
+         */
+        menu_icon?: string;
+        /**
+         * The position in the menu order the post type should appear.
+         * To work, $show_in_menu must be true.
+         * Default null (at the bottom).
+         */
+        menu_position?: string | number;
+        /**
+         * Whether to rename the capabilities for this post type.
+         */
+        rename_capabilities?: boolean;
+        /**
+         * The singular capability name for this post type.
+         */
+        singular_capability_name?: string;
+        /**
+         * The plural capability name for this post type.
+         */
+        plural_capability_name?: string;
+        /**
+         * An array of taxonomy identifiers that will be registered for the post type.
+         * Taxonomies can be registered later with register_taxonomy() or register_taxonomy_for_object_type().
+         */
+        taxonomies?: string[];
+        /**
+         * The query var name for this post type.
+         */
+        query_var_name?: string;
+        /**
+         * Provide a callback function that sets up the meta boxes for the edit form.
+         * Do remove_meta_box() and add_meta_box() calls in the callback.
+         * Default null.
+         */
+        register_meta_box_cb?: string;
+        /**
+         * Custom text for the "Enter title here" placeholder in the title field.
+         */
+        enter_title_here?: string;
+        /**
+         * The string to use to build the read, edit, and delete capabilities.
+         * May be passed as an array to allow for alternative plurals when using this argument as a base to construct the capabilities,
+         * e.g. array('story', 'stories').
+         * Default 'post'.
+         */
+        capability_type?: string | [string, string];
+        /**
+         * Array of capabilities for this post type.
+         * $capability_type is used as a base to construct capabilities by default.
+         * See get_post_type_capabilities().
+         */
+        capabilities?: {
+            [key: string]: string;
+        };
+        /**
+         * Whether to use the internal default meta capability handling.
+         * Default false.
+         */
+        map_meta_cap?: boolean;
+        /**
+         * Core feature(s) the post type supports. Serves as an alias for calling add_post_type_support() directly.
+         *
+         * Core features include 'title', 'editor', 'comments', 'revisions', 'trackbacks', 'author', 'excerpt',
+         * 'page-attributes', 'thumbnail', 'custom-fields', and 'post-formats'.
+         *
+         * Additionally, the 'revisions' feature dictates whether the post type will store revisions,
+         * the 'autosave' feature dictates whether the post type will be autosaved,
+         * and the 'comments' feature dictates whether the comments count will show on the edit screen.
+         *
+         * For backward compatibility reasons, adding 'editor' support implies 'autosave' support too.
+         *
+         * A feature can also be specified as an array of arguments to provide additional information about supporting that feature.
+         *
+         * Example: array( 'my_feature', array( 'field' => 'value' ) ).
+         *
+         * If false, no features will be added.
+         * Default is an array containing 'title' and 'editor'.
+         */
+        supports?: Array<'title' | 'editor' | 'author' | 'thumbnail' | 'excerpt' | 'trackbacks' | 'custom-fields' | 'comments' | 'revisions' | 'page-attributes' | 'post-formats'> & string[];
+        /**
+         * Whether there should be post type archives, or if a string, the archive slug to use.
+         * Will generate the proper rewrite rules if $rewrite is enabled.
+         * Default false.
+         */
+        has_archive?: boolean | string;
+        /**
+         * Triggers the handling of rewrites for this post type. To prevent rewrite, set to false.
+         * Defaults to true, using $post_type as slug.
+         * To specify rewrite rules, an array can be passed with any of these keys:
+         * - slug (string): Customize the permastruct slug. Defaults to $post_type key.
+         * - with_front (bool): Whether the permastruct should be prepended with WP_Rewrite::$front. Default true.
+         * - feeds (bool): Whether the feed permastruct should be built for this post type. Default is value of $has_archive.
+         * - pages (bool): Whether the permastruct should provide for pagination. Default true.
+         * - ep_mask (int): Endpoint mask to assign. If not specified and permalink_epmask is set, inherits from $permalink_epmask.
+         *   If not specified and permalink_epmask is not set, defaults to EP_PERMALINK.
+         */
+        rewrite?: boolean | {
+            slug?: string;
+            with_front?: boolean;
+            pages?: boolean;
+            feeds?: boolean;
+            ep_mask?: number;
+        };
+        /**
+         * Sets the query_var key for this post type.
+         * Defaults to $post_type key.
+         * If false, a post type cannot be loaded at ?{query_var}={post_slug}.
+         * If specified as a string, the query ?{query_var_string}={post_slug} will be valid.
+         */
+        query_var?: boolean | string;
+        /**
+         * Whether to allow this post type to be exported.
+         * Default true.
+         */
+        can_export?: boolean;
+        /**
+         * Whether to delete posts of this type when deleting a user.
+         * If true, posts of this type belonging to the user will be moved to Trash when the user is deleted.
+         * If false, posts of this type belonging to the user will *not* be trashed or deleted.
+         * If not set (the default), posts are trashed if post type supports the 'author' feature.
+         * Otherwise posts are not trashed or deleted.
+         * Default null.
+         */
+        delete_with_user?: boolean;
+        /**
+         * Array of blocks to use as the default initial state for an editor session.
+         * Each item should be an array containing block name and optional attributes.
+         */
+        template?: Array<Block>;
+        /**
+         * Whether the block template should be locked if $template is set.
+         * If set to 'all', the user is unable to insert new blocks, move existing blocks and delete blocks.
+         * If set to 'insert', the user is able to move existing blocks but is unable to insert new blocks and delete blocks.
+         * Default false.
+         */
+        template_lock?: 'all' | 'insert' | false;
+    };
+    /**
+     * }}}
+     */
+    /**
+     * FONTS DECLARATIONS {{{
+     * This mirrors WordPress core's font-collection.json schema.
+     */
+    /**
+     * Font face settings with added preview property.
+     */
+    type FontFace = {
+        /** URL to a preview image of the font. */
+        preview?: string;
+        /** CSS font-family value. */
+        fontFamily: string;
+        /** CSS font-style value. */
+        fontStyle?: string;
+        /** List of available font weights, separated by a space. */
+        fontWeight?: string | number;
+        /** CSS font-display value. */
+        fontDisplay?: 'auto' | 'block' | 'fallback' | 'swap' | 'optional';
+        /** Paths or URLs to the font files. */
+        src: DataSources.DataReference | DataSources.DataReference[];
+        /** CSS font-stretch value. */
+        fontStretch?: string;
+        /** CSS ascent-override value. */
+        ascentOverride?: string;
+        /** CSS descent-override value. */
+        descentOverride?: string;
+        /** CSS font-variant value. */
+        fontVariant?: string;
+        /** CSS font-feature-settings value. */
+        fontFeatureSettings?: string;
+        /** CSS font-variation-settings value. */
+        fontVariationSettings?: string;
+        /** CSS line-gap-override value. */
+        lineGapOverride?: string;
+        /** CSS size-adjust value. */
+        sizeAdjust?: string;
+        /** CSS unicode-range value. */
+        unicodeRange?: string;
+    };
+    /**
+     * Font collection schema for WordPress Font Library.
+     */
+    type FontCollection = {
+        /** JSON schema URI for font-collection.json. */
+        $schema?: string;
+        /** Array of font families ready to be installed. */
+        font_families: Array<{
+            /** Font family settings with added preview property. */
+            font_family_settings: {
+                /** Name of the font family preset, translatable. */
+                name: string;
+                /** Kebab-case unique identifier for the font family preset. */
+                slug: string;
+                /** CSS font-family value. */
+                fontFamily: string;
+                /** URL to a preview image of the font family. */
+                preview?: string;
+                /** Array of font-face definitions. */
+                fontFace?: FontFace[];
+            };
+            /** Array of category slugs. */
+            categories?: string[];
+        }>;
+    };
+    /**
+     * WordPress Content Schema {{{
+     */
+    /**
+     * Post data type. It is inspired by the wp_insert_post() arguments,
+     * but it diverges from it in a few ways.
+     */
+    type WordPressPost = {
+        /**
+         * Username of the post author.
+         *
+         * If missing, the default value will be resolved in the following order
+         * until one is available:
+         *
+         * * Default user defined in the runner configuration.
+         * * The first administrator in the database.
+         * * The first user in the database.
+         * * A newly created user.
+         *
+         * The aggressive resolution is necessary because post_author is NOT NULL
+         * in the database schema.
+         */
+        post_author?: number;
+        /**
+         * The date of the post in UTC. Accepts format 'YYYY-MM-DD HH:MM:SS'.
+         * Can be used to schedule future posts (when used with post_status: 'future').
+         *
+         * @default Current time
+         */
+        post_date?: string;
+        /**
+         * The main post content. Can contain HTML, shortcodes, etc.
+         * While technically optional, posts are usually expected to have content.
+         *
+         * @default ''
+         */
+        post_content?: string;
+        /** The post title. */
+        post_title: string;
+        /** The post excerpt. Default empty. */
+        post_excerpt?: string;
+        /** The post status */
+        post_status?: 'publish' | 'pending' | 'draft' | 'auto-draft' | 'future' | 'private' | 'inherit' | 'trash';
+        /** The post type (e.g., 'post', 'page'). Default 'post'. */
+        post_type?: string;
+        /**
+         * Whether comments are allowed ('open' or 'closed').
+         *
+         * @default 'open'.
+         */
+        comment_status?: 'open' | 'closed';
+        /** A password to protect access. Default empty. */
+        post_password?: string;
+        /** The URL slug. Default sanitized post_title for new posts. */
+        post_name?: string;
+        /** Post parent name for hierarchical post types (e.g., pages). Default empty. */
+        post_parent_name?: string;
+        /** Menu order within a post type. Default 0. */
+        menu_order?: number;
+        /** MIME type for attachments. Default empty. */
+        post_mime_type?: string;
+        /** Global Unique ID. Default empty. */
+        guid?: string;
+        /** Array of category slugs. Defaults to the site's default category. */
+        post_category?: string[];
+        /** Array of tag names. Default empty. */
+        post_tags?: Array<string>;
+        /**
+         * Taxonomy terms keyed by taxonomy name.
+         * For hierarchical taxonomies: array of term names.
+         * For non-hierarchical: array of term names or slugs.
+         *
+         * Examples:
+         * ```json
+         * tax_input: {
+         *   // For hierarchical taxonomies like categories
+         *   "category": ["Books", "Fiction", "Science Fiction"],
+         *
+         *   // For non-hierarchical taxonomies like tags
+         *   "post_tag": ["bestseller", "featured", "summer-reading"],
+         *
+         *   // For custom taxonomies
+         *   "genre": ["mystery", "thriller"],
+         *   "author": ["Jane Doe", "John Smith"]
+         * }
+         * ```
+         */
+        tax_input?: Record<string, Array<string>>;
+        /**
+         * Post meta keyed by meta key to value. Default empty.
+         *
+         * Examples:
+         * ```json
+         * meta_input: {
+         *   // Simple values
+         *   "price": "19.99",
+         *   "in_stock": true,
+         *   "stock": 42,
+         *
+         *   // Array values
+         *   "related_products": [123, 456, 789],
+         *   "product_colors": ["red", "blue", "green"],
+         *
+         *   // Object values
+         *   "_product_attributes": {
+         *     "color": {
+         *       "name": "Color",
+         *       "value": "Red",
+         *       "position": 0,
+         *       "visible": true
+         *     }
+         *   },
+         *   "seo_data": {
+         *     "title": "Custom SEO Title",
+         *     "description": "Custom meta description",
+         *     "keywords": ["product", "featured"]
+         *   }
+         * }
+         * ```
+         */
+        meta_input?: Record<string, JsonValue>;
+        /**
+         * Specifies the page template file to use.
+         * This parameter only applies if post_type is 'page'. For other post types, it's ignored.
+         * Provide the template filename (e.g., 'template-contact.php'). Include subdirectory if applicable (e.g., 'templates/full-width.php').
+         * To set a template for non-page post types, use meta_input with key '_wp_page_template'.
+         *
+         * @default ''
+         */
+        page_template?: string;
+    };
+    /**
+     * }}}
+     */
+    type ActivatePluginStep = {
+        step: 'activatePlugin';
+        /**
+         * Path to the plugin directory as absolute path
+         * (/wordpress/wp-content/plugins/plugin-name); or the plugin entry file
+         * relative to the plugins directory (plugin-name/plugin-name.php).
+         */
+        pluginPath: string;
+        /**
+         * Human-readable name of the plugin for the progress bar.
+         *
+         * For example, with the following Blueprint:
+         *
+         * ```json
+         * {
+         *     "steps": [
+         *         {
+         *             "step": "activatePlugin",
+         *             "pluginPath": "wordpress-seo/wp-seo.php",
+         *             "humanReadableName": "Yoast SEO"
+         *         }
+         *     ]
+         * }
+         * ```
+         *
+         * The progress bar will show "Activating Yoast SEO" instead of
+         * "Activating wordpress-seo/wp-seo.php".
+         */
+        humanReadableName?: string;
+    };
+    type ActivateThemeStep = {
+        step: 'activateTheme';
+        /**
+         * The name of the theme directory inside wp-content/themes/
+         */
+        themeDirectoryName: string;
+        /**
+         * Human-readable name of the theme for the progress bar.
+         *
+         * For example, with the following Blueprint:
+         *
+         * ```json
+         * {
+         *     "steps": [
+         *         {
+         *             "step": "activateTheme",
+         *             "themeDirectoryName": "twentytwentythree",
+         *             "humanReadableName": "Twenty Twenty-Three"
+         *         }
+         *     ]
+         * }
+         * ```
+         *
+         * The progress bar will show "Activating Twenty Twenty-Three" instead of
+         * "Activating twentytwentythree".
+         */
+        humanReadableName?: string;
+    };
+    type CpStep = {
+        step: 'cp';
+        fromPath: string;
+        toPath: string;
+    };
+    type WordPressConstants = Record<string, boolean | string | number> & Partial<{
+        WP_DEBUG: boolean;
+        WP_DEBUG_LOG: boolean;
+        WP_DEBUG_DISPLAY: boolean;
+        SCRIPT_DEBUG: boolean;
+    }>;
+    type DefineConstantsStep = {
+        step: 'defineConstants';
+        constants: WordPressConstants;
+    };
+    type ImportContentStep = {
+        step: 'importContent';
+        content: ContentDefinition[];
+    };
+    type ImportMediaStep = {
+        step: 'importMedia';
+        media: MediaDefinition[];
+    };
+    type ImportThemeStarterContentStep = {
+        step: 'importThemeStarterContent';
+        /**
+         * The name of the theme to import content from.
+         */
+        themeSlug?: string;
+    };
+    type MkdirStep = {
+        step: 'mkdir';
+        path: string;
+    };
+    type MvStep = {
+        step: 'mv';
+        fromPath: string;
+        toPath: string;
+    };
+    type RmStep = {
+        step: 'rm';
+        path: string;
+    };
+    type RmdirStep = {
+        step: 'rmdir';
+        path: string;
+    };
+    type RunPHPStep = {
+        step: 'runPHP';
+        /**
+         * The PHP file to execute.
+         */
+        code: DataSources.DataReference;
+        /**
+         * Environment variables to set for this run.
+         */
+        env?: Record<string, string>;
+    };
+    type RunSQLStep = {
+        step: 'runSQL';
+        source: DataSources.DataReference;
+    };
+    /**
+     * Sets the site language and download translations for WordPress core
+     * and all the installed plugins and themes.
+     */
+    type SetSiteLanguageStep = {
+        step: 'setSiteLanguage';
+        /**
+         * The language to set, e.g. 'en_US'
+         */
+        language: string;
+    };
+    type SetSiteOptionsStep = {
+        step: 'setSiteOptions';
+        options: Record<string, JsonValue>;
+    };
+    /**
+     * Unzips a file. While this step is not strictly necessary, it is
+     * very convenient for:
+     *
+     * * Working with GitHub releases that output doubly zipped data.
+     * * Preprocessing zipped data before using them in the Blueprint.
+     */
+    type UnzipStep = {
+        step: 'unzip';
+        /**
+         * The zip file resource to extract.
+         */
+        zipFile: DataSources.DataReference;
+        /**
+         * The path to extract the zip file to inside the virtual filesystem.
+         */
+        extractToPath: string;
+    };
+    type WpCliStep = {
+        step: 'wp-cli';
+        command: string;
+        wpCliPath?: string;
+    };
+    type WriteFilesStep = {
+        step: 'writeFiles';
+        files: Record<string, DataSources.DataReference>;
+    };
+    type PluginStep = {
+        step: 'installPlugin';
+    } & PluginObjectDefinition;
+    type ThemeStep = {
+        step: 'installTheme';
+        /**
+         * Whether to activate the theme after installing it.
+         *
+         * This is not a part of the theme definition. Only the step
+         * can explicitly provide this option. The default value is `true`.
+         */
+        active?: boolean;
+    } & ThemeObjectDefinition;
+    type Step = ActivatePluginStep | ActivateThemeStep | CpStep | DefineConstantsStep | ImportContentStep | ImportMediaStep | ImportThemeStarterContentStep | PluginStep | ThemeStep | MkdirStep | MvStep | RmStep | RmdirStep | RunPHPStep | RunSQLStep | SetSiteLanguageStep | SetSiteOptionsStep | UnzipStep | WpCliStep | WriteFilesStep;
+    type JsonValue = string | boolean | number | JsonValue[] | {
+        [key: string]: JsonValue;
+    };
+    export {};
+}