Minn\Rest

The engine's routes in the reference's index form.

The API for one request: the shared services and the route table.

Who is making this request.

A post type's list as its route serves it (the caller, the statuses, the parameters, the query, the totals and page links), each post given the shape asked for: the facade's controller class shapes them itself.

A revision (or autosave) row as wp/v2 shapes it, in the view or edit context. @param array<string, mixed> $row

Saves a user's autosave of a post in its one slot per author; the revision's id.

The wp/v2 post shape.

The wp/v2 term shape.

The wp/v2 comment shape.

The wp/v2 menu shape.

One menu item as wp/v2 shapes it in a context (view, edit or embed); empty when there is none. @return array<string, mixed>

One attachment as wp/v2 shapes it in a context (view, edit or embed), links included; empty when there is none. @return array<string, mixed>

One attachment's wp/v2 links in a context, without rendering the rest of it; empty when there is none. @return array<string, mixed>

A template as wp/v2 shapes it in a context, for the route's own type (templates or template parts). @return array<string, mixed>

A theme in the wp/v2 shape, links included, before rest_prepare_theme. @return array<string, mixed>

A response's data with its embeddable links answered in-process as this caller; every rel when none is named. @param list<string> $rels @return array<string, mixed>

The wp/v2 user shape.

The post types the surface knows.

Runs the request as a user already proven by the outer request, for the in-process calls plugin code makes, or as the user plugin code settled (determine_current_user; 0 for nobody); a user who no longer exists leaves the caller as the request itself resolves it.

Resolves a REST route (from the path or from ?rest_route=) to a response.

The headers the reference's server adds to every REST answer over HTTP (probe rest-server-headers): X-Robots-Tag noindex always; and, while rest_send_cors_headers stays hooked, for a request from an Origin the CORS headers echoing it with Vary: Origin, otherwise Vary: Origin for a GET from someone not signed in. A signed-in caller's answer also carries the no-cache headers (rest_send_nocache_headers, nocache_headers). The CORS header lists go through rest_exposed_cors_headers and rest_allowed_cors_headers, handed the route's request.

A REST answer as it leaves over HTTP: pointing at the API's root, unless it carries a Link header of its own (a batch's parts do not).

A post of a REST type the engine has no route for (one under a namespace of its own, probe namespaced-type) created, updated or deleted by the engine's own writer, for the type's controller, whose permission checks have already run.

The engine's own answer to a route, or null when no engine route takes it; the runtime's table is never consulted. This is what the runtime's server calls for a core route, so a route the engine declines cannot bounce between the two. $as is the caller's own request object, which the route's parameters are set on.

The methods this caller may use on one of the engine's routes, as its Allow header lists them (rest_send_allow_header asks).

The user's application passwords.

Mints one; the plain password is in this answer only.

Removes every one.

The password the current Basic auth session used.

One password by uuid.

Renames one.

Removes one.

The check as the router takes it.

Throws the refusal the declared arguments earn, or returns. @param array<string, string> $captures what the path named, for a route whose parameters depend on it

The requests answered in turn.

The batch body's requests in the reference's normalised form.

The block's markup, as {"rendered": "..."}.

Every block type, or those of one namespace (?namespace=).

One namespace's block types.

One block type.

A block type's fields in the reference's order, as the route and WP_REST_Block_Types_Controller show them: its registration (supports {} when it has none), its styles (its own, then those registered for it), its variations as built when asked, and the first handle of each asset kind as the old single field (probe rest-block-controllers).

The blocks the caller may edit; an empty list for anyone else.

One block. Editing context is the posts machinery's own gate (rest_forbidden_context); a view is refused to anyone who cannot edit posts, and a trashed or unknown block is not found rather than refused.

Creates a block: a pattern's create_posts is publish_posts.

Updates a block.

Trashes or deletes a block.

Settles the caller as a session already proven elsewhere: an in-process request a plugin makes through rest_do_request() carries no nonce, so it runs as whoever the outer request resolved.

Settles the caller as nobody: plugin code (determine_current_user) signed the request out.

Whether a sign-in cookie vouches for this caller (or failed to, for want of its nonce): a cookie's nonce vouches for its own user only.

Has the cookie and nonce checked again on the next question: a plugin's nonce lifetime (nonce_life) is heard only once plugins load.

Settles the caller as one whose cookie's nonce does not vouch for the user plugin code named.

The session, or null for an anonymous or refused caller.

The caller's user id, 0 when anonymous.

Whether the caller holds a capability, on a post when given. With plugins loaded the answer is WordPress's: the same mapping, then map_meta_cap and user_has_cap, where role editors and lock plugins have their say.

Whether the caller can edit posts of some type shown in REST: what the reference asks before showing statuses, block types and the active theme. A plugin's types count once plugins are loaded.

The capability engine.

The session, or the reference's refusal: a bad nonce is always 403 rest_cookie_invalid_nonce; no identity is the caller-supplied error.

The floor every Minn Admin route shares: a signed-in caller who can edit posts, plus any further capability named, all refused with the same rest_forbidden the reference uses. Returns the caller's id.

403 rest_forbidden unless the caller holds every capability named.

401 for an anonymous caller, 403 for one who is signed in but refused.

Every route declared by a class under the source directory, in file order, then declaration order.

The rows as the JSON catalogue: a version line and one entry per route.

The keywords a profile keeps: draft-04's whole set, the REST API's for any other profile.

A schema with only the allowed keywords, keyed by keyword (the values do not matter), trimmed all the way down.

The arguments before plugins see them: a parameter maps when the collection (as rest_comment_collection_params left it) still has it.

A comment in the context asked for, through rest_prepare_comment when a plugin hooks it.

The REST URL builder.

The comments list as the reference serves it: the request's WP_Comment_Query through rest_comment_query, its totals (counted again when a page comes back empty), and the comments the caller may read.

One comment, if the caller may read it.

A signed-in reply; the author fields come from the user.

Status flips and content or author edits, for moderators.

Trash remembers where the comment came from; force removes it outright.

The context a request names, view when it names none or names one the route does not serve.

Whether this is the edit context.

A declared type's list.

A declared type's single post.

Creates a post of a declared type.

Updates a post of a declared type.

Trashes or deletes a post of a declared type.

A registered taxonomy's terms.

One term of a registered taxonomy.

Creates a term in a registered taxonomy.

Updates a term of a registered taxonomy.

Deletes a term of a registered taxonomy.

Null when _embed is absent; [] for every rel; otherwise the rels asked for. @return ?list<string>

Decorates a finished response: the embed context, then _embedded, then the deferred _fields.

A response's data with its embeddable links answered (the runtime's WP_REST_Server::embed_links): every rel when none is named.

An item cut to the embed shape of its object type (a post type, a taxonomy, attachment, user or comment); any other kept whole. @param array<string, mixed> $item @return array<string, mixed>

The router's routes as route => methods, the way the index lists them.

A route attribute pattern as the reference writes routes: `{id:\d+}` becomes `(?P<id>\d+)`, a bare capture matches one segment, a `{rest*}` capture the remainder, and a literal constraint (`{base:posts}`, or the alternation `{base:posts|pages}`) expands to one route per literal. The declared-type routes are written once as a `{base:[...]}` catch-all; they list per declared type under its rest_base (as the reference lists a registered type) and not at all when no type is declared, so nothing listed answers no-route.

Throws rest_post_exists for a non-empty id in the body or the query.

The _fields selection a query carries, or null for everything.

The same paths plus _links whenever _embedded is among them: the reference's single-object rule under _embed.

Whether a top-level field is among the selection: named whole, below one of its paths (title.rendered), or above one (a path into it).

The object with only the selected fields.

The fields a response keeps when a caller names some: known fields as given, dotted paths whose root is known, and `id` whenever it exists.

The saved styles by id: anyone who edits posts may read them, editing context needs the theme.

Replaces the title, settings, or styles the body names; what it leaves out stays.

The style variations the active theme ships; listed ahead of the theme's own route, whose pattern would take this path too.

The active theme's settings and styles, the engine's defaults underneath.

The revisions of the saved styles, newest first; all of them unless per_page pages them.

One revision of the saved styles.

The saved styles: the title both ways, settings by origin, styles with their presets resolved, the links; in editing context the app's lock fields too, which a global-styles post never carries.

The active theme's own styles as the themes/{stylesheet} route answers them.

One revision row: both nodes when the body holds anything at all, neither when it is blank, then the row's own facts; no links.

The REST index: namespaces, routes, and the site's description.

One namespace's index, as the reference answers /wp-json/wp/v2 (or oembed/1.0): the namespace, its routes (the namespace root among them), and the link up to the root index. A namespace the engine does not serve is left to the runtime, whose plugins may own it.

The installed themes the caller may see.

One theme by its stylesheet.

A theme in the wp/v2 shape, its links included, before rest_prepare_theme (the runtime's WP_REST_Themes_Controller shapes through here); the request is what the supports' callbacks are handed.

One link as a response serves it: its attributes, then its href; a self link's target hints after the href, where the reference adds them.

An answer's compact links as the reference keeps them on a response: each link under its full relation (a curie's short name expanded, the curies themselves dropped), with its href and its other attributes.

Links with their curies applied, as the reference compacts them.

The settings shown in REST, by REST name, with the arguments the filters are handed.

Every shown setting's value. @return array<string, mixed>

Writes the shown settings a body names, after refusing the values their schemas refuse.

The media list: the post lists' own path for attachments (probe rest-media-lists), each item in the media shape.

One attachment.

Uploads a file and creates its attachment.

The editable fields the app uses.

Attachments go to the trash only when MEDIA_TRASH (or rest_attachment_trashable) says so; force removes the row, its meta, and its files.

An attachment in the context asked for, as rest_block_hooks_post_types has it (attachments only when a plugin lists them), through rest_prepare_attachment when a plugin hooks it.

The REST URL builder.

The attachment's links in a context: itself (with the methods the caller may use), its collection and type, its author, replies, the post it is attached to, and in the edit context the actions the caller may take; curies when any rel is the API's own.

The wp/v2 menu-item shape, through rest_prepare_nav_menu_item when a plugin hooks it.

The wp/v2 menu shape.

Every classic menu.

One menu.

Creates a menu.

Renames or re-describes a menu.

Deletes a menu and its items.

The items of a menu.

One menu item.

Creates a menu item.

Updates a menu item.

Deletes a menu item.

The menu locations the theme and plugins register (none for a block theme without plugins), keyed by name; edit_theme_options to view.

One menu location.

The navigation posts.

One navigation post.

Creates a navigation post.

Updates a navigation post.

Trashes or deletes a navigation post.

The first refusal among the request's parameters, or null when all pass.

The parameters after sanitising, or the refusal listing every invalid one.

The plugins list, optionally by status.

Installs a directory plugin by slug, optionally activating it; answers 201 with the item.

One plugin.

Activates or deactivates a plugin.

Deletes an inactive plugin.

A WordPress plugin's item from its headers, as the reference's controller shapes one (the runtime's WP_REST_Plugins_Controller shapes through here too): the headers translated and cut to the allowed markup once for the fields and once more, marked up, for the rendered description.

The judge as the router takes it.

Throws the refusal the policy names, or returns.

The parameters of the list a {base} capture names; none for a base no REST post type has.

The parameters of a post type's list, by the type's name. @return array<string, array<string, mixed>>

A post type's list parameters asked afresh, as the reference's list asks for them each time it runs: rest_{type}_collection_params runs again.

A post type's list parameters as built, for the type in any namespace: before rest_{type}_collection_params and the optional marks, for the facade's controller class, which adds its callbacks and runs the filter itself.

The allowed MIME types by media type (the part before the slash), in the order the site allows them, each once.

The arguments before plugins see them.

The query variables from the arguments plugins left: each through rest_query_var-{name}, and the list's orderby names as the query's.

The view-context object, through rest_prepare_{type} when a plugin hooks it; with a _fields selection, the rendered title, content and excerpt only when it asks for them, as the reference renders only what is asked.

The edit-context object, its raw content given its hooked blocks, through rest_prepare_{type} when a plugin hooks it; with a _fields selection, rendered only as far as it asks.

A post's permalink as of now: pretty once live with a slug, ?p= (or ?page_id=) before.

The rest_base of a type.

The _links of a post in the view context.

Whether a live post carries an autosave newer than its saved revision.

The OTHER user holding a live _edit_lock (150 second window), or null.

The view links plus the caller's verbs and cap-gated wp:action-* entries.

A MySQL datetime in the reference's ISO form.

The posts or pages list.

The list for any post type as the reference serves it (probe rest-post-lists): the caller and the statuses judged, the request's parameters sanitized, the query arguments through rest_{type}_query and rest_query_var-*, a WP_Query (so pre_get_posts and every query filter run), then each post the caller may read (or edit, in the edit context) shaped (by $shape when the type has its own object, as media does). The totals are the query's, counted again without the page when a later page came back empty. A media search also matches file names, as the reference's does.

One post or page.

One post of any type, with the reference's read rules.

A viewable type's single post points at its page on the site.

Creates a post or page; one asked for with an id is refused before the caller is judged (patch-security).

Creates a post of any type from the body.

Updates a post or page.

Updates a post of any type from the body.

Trashes or deletes a post or page.

Trashes a post of any type, or deletes it with force.

A body's meta must be an object of keys (probe rest-meta). @param array<string, mixed> $body

A field that may arrive as a scalar or as {raw: ...}.

The item with the type's registered fields added, answering the request. @param array<string, mixed> $item @return array<string, mixed>

Runs the update callbacks for the fields the request's body names; an error one returns is thrown as the write's answer.

The context the item is answered in, set on the request as the reference's controllers set it: a write and a delete answer in edit (a term's delete in view); a read in the one asked for, or view.

The names of the fields registered for the type that show in the context. @return list<string>

A plugin's type in the view context (probe rest-plugin-types): the shared fields, then only what the type supports (title, editor, excerpt, author, thumbnail, page attributes, comments, formats, custom fields), its parent when hierarchical, each REST taxonomy's term ids under its REST base, the class list and links.

The type when plugin code registered it (not a built-in), or null.

Whether the type supports the feature (title, editor, author...).

Whether the type's posts have parents.

The REST base the type's routes live under, with its namespace.

The taxonomies the type shows in REST, REST base => taxonomy, in registration order. @return array<string, string>

The rendered title.

The rendered content.

The rendered excerpt.

The post made current and set up for a response that renders none of its text, as the reference sets up every item it prepares.

A post's class list as get_post_class hands it back once plugin code filters post_class (WooCommerce drops hentry and adds a product's stock and type): the filter's answer without repeats, in order.

One item, shaped by the request's own _fields: what nearly every handler ends with.

One object as a response, the selected fields applied.

A post's answer pointing at its page on the site, as a viewable type's single item does.

A list response with the total and page-count headers.

A REST error as the reference's error body.

The meta field of an object in a context (the one the request answers in, when none is named), keyed by REST name. @return array<string, mixed>

One field's value for an object: a single key's first stored value (its default when none), a multiple key's each one, prepared for the response.

Applies the meta a write request names, when it names any.

Applies a request's meta to an object; the gathered refusals are thrown.

Applies a request's meta to an object, key by key in registration order; the refusals come back. @return list<\WP_Error>

The keys registered to show in REST for an object type and subtype, each with its REST name, whether it is single, its schema (a multiple key's an array of its own) and its prepare callback; keys of a type REST does not know are left out.

A value for the response: through the field's prepare callback, or checked against its schema (null when it does not fit) and cast. @param array<string, mixed> $field

A single key stored: an unchanged value is left alone, then the user must be allowed to edit it. @param array<string, mixed> $field

A multiple key stored as a list, once the user may edit it. @param array<string, mixed> $field @param array<mixed> $values

A key deleted once the user may delete it (a single key's invalid stored value refuses null). @param array<string, mixed> $field

Whether a value sanitizes to what is stored (scalar types compared as the text the store keeps). @param array<string, mixed> $field

A type's empty value: '' for a string, false, 0, or an empty list.

A URL under the site's home.

The URL of a REST route, pretty or plain as the site is set.

The curies entry every wp/v2 _links block ends with.

Real revisions, not autosaves.

One revision of a post, page, or block.

A revision deleted for good, answered as it was; never trashed. The reference grants deleting a revision to nobody by default, so a request that passes the parent's check is refused at the revision's.

The autosaves of a post.

The caller's autosave of the parent, whichever autosave id is asked for; the edit view names its preview.

One autosave slot per author; the reply carries a preview link.

One revision row as wp/v2 serves it (autosaves and revisions alike).

Route arguments with the shared args folded into each endpoint.

Every route the engine serves, the root and each namespace's index among them, and the namespaces.

The namespace a route is listed under: its first two segments when the second is a version. The routes the reference's server registers itself, the batch route among them, belong to none, so none is listed for them and their path answers no namespace index.

The first route whose pattern takes the path, as the reference finds the route an OPTIONS request describes; null when none does.

One route as the index describes it, or null when hidden.

The handler for a method and path across the registered namespaces, or the refusal.

The first registered route whose pattern matches a path, whatever the method, with its handlers; null when none does. An OPTIONS request is answered from this.

Registered endpoints as a route table with their options.

The route's answer with the server's filters around it, or as the route gives it when no plugin can hear.

The post types whose REST answers and saves get their hooked blocks, before plugins say.

Remembers the request a REST call is answering, for the filters its items pass through (on the request's own runtime).

Runs an in-process REST call answering its own request (the filters hand plugins that one), then puts back the request it interrupted.

A post-shaped item (a post, a page, a pattern, a navigation, an attachment, any other type) through rest_prepare_{type}, given its hooked blocks first; the post it describes is looked up only when a hook needs it.

A prepared post about to be saved, as rest_block_hooks_post_types has it: a type it lists has its content's ignored hooked blocks marked, a navigation's root list put in meta_input, as the reference's update_ignored_hooked_blocks_postmeta does; asked of every save.

One item through a rest_prepare filter.

What plugin code decides before any route runs, engine routes included, in the reference's order: rest_authentication_errors may refuse the request, rest_pre_dispatch may answer it outright, and a route a rest_endpoints filter removed is no route at all. Null lets the engine's router proceed.

What plugin code decides before a route runs, for a request inside another (an embedded link) as for the first: rest_pre_dispatch may answer it outright, and a route a rest_endpoints filter removed is no route at all. Null lets the router proceed.

Null when the runtime has no route for the request either.

The methods of a plugin's route whose handler lets this request through (a handler with no permission callback does). @return list<string>

The methods a self link's caller may use there, as the reference hints them on every self link it serves (targetHints.allow): the route the link names, each of its methods whose handler lets this caller through; null when no route of the runtime's takes the link. A route the engine answers itself is judged by its policies, as its Allow header is (probe rest-registry-controllers).

The engine's index plus the namespaces and routes the runtime holds.

An in-process call's own request object stands for the engine's request: the server sets its route's parameters on it, as the reference's dispatch does.

The request as the list's handler reads it: its parameters with their defaults, sanitized by their schemas, as plugins' filters see it too.

The request as the runtime's server reads it, and as a REST filter or action hands it to plugins: the same object each time.

Keeps the route and handler a request matched, for the response plugins see at serving.

An engine refusal as plugins handle one.

An engine answer as plugins handle one: its data decoded (an empty object stays one), its links on the response rather than in the data, its status and headers.

A route's own headers as the reference's response object holds them: a list's totals are numbers, but the comments list's stay text.

One item a response carries, as a response object: its data without _links, the links on the response.

Whatever the filters left, as the engine sends it; what they handed back untouched is the engine's own answer, byte for byte.

The server's last word on any REST answer, engine or plugin route, as the reference serves one: rest_post_dispatch may change it, rest_pre_serve_request may serve it itself (what it prints is the body), and rest_pre_echo_response may rewrite the data echoed. With nothing hooked, the answer goes out as it is.

Whether the answer went out as oEmbed's XML. The reference prints it in rest_pre_serve_request ahead of rest_send_cors_headers, so none of the CORS headers follow it, Vary: Origin among them.

A callback's return as a response object, an error converted.

The runtime's REST server, the one door to it (built, with rest_api_init, on first use).

Every keyword a route schema may carry, in the reference's order; the endpoint subset drops the three descriptive ones.

Whether a value satisfies a schema, or the reference's refusal.

A schema's anyOf and oneOf: which of their schemas a value matches, and the refusal when not as wanted.

One type's own checks, as the per-type validators run them: a number's bounds before an integer's wholeness, and no enum or format.

Whether a value is one of the schema's enum, coerced to the schema's type first when it names one.

A value coerced to its schema's types.

Drops the properties whose schema does not list the context; an array whose items do not is emptied.

The first anyOf branch the value validates against.

The argument map a route derives from an item schema: every writable property with the default validators, its keywords, defaults and required flags on the create route only, and any arg_options overrides.

A value with each empty array the schema calls an object made one (it encodes as {}), through properties, additional properties, list items and the value as a whole (probe rest-view-config).

The schema with additionalProperties closed on every object.

The first of an anyOf's schemas the value matches, each without a type taking the choice's own, or the refusal for matching none (probe rest-media-actions).

The one of a oneOf's schemas the value matches, each without a type taking the choice's own; "first" settles for the first match. Matching none is refused as matchAny() refuses it; matching several names them when every one has a title, with their positions.

The refusal for a value no schema of a choice matched (probe rest-media-actions). With one schema, its refusal is named. Otherwise the refusals that say only the value is not the schema's type are set aside, and one left is named. Of several left, when the first is an object's, the one whose properties share the most keys with the value is named (the first of a tie, none when none share). Then, when every schema has a title, they are listed; else the plain refusal.

The refusal for a value that matched none of a combinator's schemas, worded from the one that came closest: its title when it has one (an empty title still reads as one), and that schema's own reason.

One captured schema by name; an empty array when there is none. @return array<string, mixed>

Whether a value reads as a boolean, the strings included.

The boolean a value reads as.

Whether a value is a whole number.

Whether a value reads as a list, a comma-separated string included.

The list a value reads as.

Whether a value reads as an object.

The object a value reads as, as an array.

The first of the schema's types, in the order it lists them, that the value reads as (an empty string is a string when that is allowed); '' when none.

Whether two values are equal by the reference's loose rules.

The schema of the patternProperties entry a property name matches, or null.

Whether a value matches a schema pattern, read as the reference reads one: unanchored, # escaped, UTF-8.

Whether no two items are equal once their keys are sorted; types stay apart, so 1 and "1" differ.

The first array's entries whose keys the second has too, at every level where both hold an array.

Keys sorted at every level, so two equal structures serialise the same.

A timestamp for an RFC3339-shaped date, false otherwise; $forceUtc reads the offset as Z.

A hex colour as given, or false.

Whether a value is a version-4 uuid.

A comma- or space-separated string as a list.

Search across post types with the reference's relevance order.

The services for one request, none made yet.

The service registered under a class name. Only the names in NAMED answer; anything else is a programming error and says so at once.

The record lookups the policy gate asks before it judges a caller.

The database door.

The request being answered.

The site root, no trailing slash.

wp-content under the site root.

The users repository.

The posts repository.

The terms repository.

The comments repository.

The site's options.

The post writer.

Revisions and autosaves.

The site editor's saved global styles.

The active theme's global styles and variations.

Classic menus and their items.

What wp-content holds: plugins, themes, drop-ins.

Link building from the permalink structure.

REST URL building.

The capability engine.

Who is making this call.

The session store.

Application passwords for Basic auth.

The extension loader.

The post types the REST surface knows.

The taxonomies the REST surface knows.

The uploads directory.

Stores an upload as an attachment.

The JSON Schema validator, with the reference's filters passed in.

The Minn Admin bundle on disk.

Installing and removing themes and extensions.

The debug log reader.

Update checks and offers.

Locales and the app's catalogs.

The app's per-user appearance.

The app's per-user hidden views.

What happened lately.

The overview payload.

Minn's own releases, asked of GitHub once a day.

Minn's changelog, read from its repository.

Minn Admin's changelog, read from its repository.

Minn's version and the release on offer, behind the app's update banner.

The engine replacing itself with a release.

The bell feed.

The System view's payload.

The active block theme's templates; null under a classic theme, where the routes answer as the reference does when it never registered them.

Writes block templates; null under a classic theme.

The wp/v2 post shape.

The wp/v2 term shape.

The wp/v2 user shape.

The wp/v2 media shape.

The wp/v2 comment shape.

The body of a write, every registered setting by its key, as the reference describes it.

Every registered setting with its current value.

Writes the registered keys in a body, already validated against SCHEMA, in the stored form; unregistered keys are ignored. Without plugins loaded there is nobody to tell (LiveSettings writes through update_option when there is).

The site settings: read, or write from the body.

Every sidebar: those the sidebars option lists, then any other registered one. Someone who cannot edit theme options sees only the sidebars shown in REST, and is refused when there are none (probe rest-sidebar-classes).

One sidebar: anyone's to read when it is shown in REST, otherwise for someone who can edit theme options.

Saves a sidebar's widgets, in the order given.

The registered widget types, by id base.

One widget type.

A widget type's form and preview for settings that are not saved: the settings sent (encoded with their hash) updated from the form's fields, the form for them (number -1 unless one is sent), the widget as the_widget shows it, and the settings encoded again.

The widgets are registered on init; a runtime that stopped short of it registers them now. Without the runtime there are no widgets to serve.

The statuses the caller may see.

One status.

Whether the record exists.

Whether a post of the type exists.

Whether a term of the taxonomy exists.

Every taxonomy the surface knows, by slug.

One taxonomy by slug, or null.

The taxonomies attached to a post type, in registry order. @return array<string, array>

The reference's view-context projection: the keys an anonymous reader sees.

The rest_base of a template type.

The wp/v2 template shape.

The templates list.

The template parts list.

The template a slug would use: the first in its hierarchy the theme or the site has.

The same lookup under the parts route: it searches templates, not parts, as the reference's does.

One template.

One template part.

Creates a template.

Creates a template part.

Saves a template.

Saves a template part.

Deletes a customised template.

Deletes a customised template part.

The parameters of the list a {base} capture names; none for a base no REST taxonomy has.

A term as get_term hands it back.

The arguments before plugins see them.

A term as its REST base shows it, through rest_prepare_{taxonomy} when a plugin hooks it.

The REST URL builder.

The taxonomy behind a rest_base.

A taxonomy plugin code registered to show in REST under wp/v2, by its REST base (probe rest-plugin-types), as a term route's config: its terms nest when it is hierarchical, and its posts are those of the first type it belongs to.

A taxonomy's term list as the reference serves it: the request's get_terms (wp_get_object_terms for a post's) through rest_{taxonomy}_collection_params and rest_{taxonomy}_query, counted by wp_count_terms without the page.

One category or tag.

Tags and pattern categories are open to edit_posts holders; categories need manage_categories.

Updates a category or tag.

The default category is capability-denied before the force check.

What creating a term needs (probe rest-plugin-caps): a plugin's taxonomy, its edit_terms when hierarchical and its assign_terms when flat; categories, manage_categories; the others, edit_posts.

Every post type the surface knows, by slug.

One post type by slug, or null.

The type behind a rest_base, or null.

The rest_base of every type an extension declared or plugin code registered under wp/v2. @return list<string>

Every base the {base} routes serve: the declared post types' and the taxonomies plugin code registered to show in REST under wp/v2.

Whether the engine serves this type through its {base} routes: an extension declared it, or plugin code registered it to show in REST under wp/v2 (probe rest-plugin-types).

The types a post search covers: the built-in post and page, the ones extensions declare, and the public types plugin code shows in REST, as the reference's post search handler takes them.

The rest_base of a type slug.

The page's four details, read from its markup; addresses made whole against the page's own. @return array{title: string, icon: string, description: string, image: string}

The list's parameters (the route has no captures).

The arguments before plugins see them, for a reader who is a 'lister' (may list users) or 'public'.

A user as the view context shows one, through rest_prepare_user when a plugin hooks it.

A user as the edit context shows one, through rest_prepare_user when a plugin hooks it.

Gravatar URLs in the sizes the reference emits (sha256 of the email).

The signed-in user.

Updates the signed-in user; signed out there is no such user (404), and the Allow header leaves the writes out.

Deletes the signed-in user as users/{id} deletes any; signed out there is no such user (404).

The users list as the reference serves it: the request's WP_User_Query through rest_user_collection_params and rest_user_query (a reader who may not list users sees published authors only), its totals (counted again without the page when it found none), and the users it found.

One user.

Engine-created users carry real scheme hashes and the full default meta set.

Updates a user.

reassign is REQUIRED (checked before the user lookup), and so is force.

A configuration with a patch applied in a mode (set, merge, replace, remove), and the problems met: [function or null for the mode's own method, words].

A value with every null in it removed, lists closed up.

The identity a list member is matched by: a word itself, a map's id or slug; null for none.

A widget in a sidebar, its form and settings in the edit context. @return array<string, mixed>

A widget's settings, encoded and signed, and raw when it shows them. @return array<string, mixed>

The registered widgets, sidebar by sidebar.

One widget.

Creates a widget in a sidebar (the inactive widgets unless one is named).

Saves a widget's settings and moves it, as the body asks.

Deletes a widget with force; without, sends it to the inactive widgets.