@loopress/cli 0.32.2 → 0.34.0

package/dist/lib/rollback-materialize.js

@@ -1,13 +1,16 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { z } from 'zod';
 import { getAcfKey } from '../utils/acf-format.js';
+import { writeBlock } from '../utils/block-format.js';
 import { CPT_SPEC, fileExtension, formatDeclaredFile, META_SPEC, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC } from '../utils/declared-type-format.js';
 import { getFormId, getFormTitle } from '../utils/form-format.js';
 import { getMenuSlug } from '../utils/menu-format.js';
 import { defaultReadonlyFor, optionFileName } from '../utils/option-format.js';
-import { buildMetaFile, buildSnippetFile } from '../utils/snippet-format.js';
+import { buildMetaFile, buildSnippetFile, normalizeSnippet } from '../utils/snippet-format.js';
 import { themeStylesFileName } from '../utils/theme-styles-format.js';
 import { toSlug } from '../utils/to-slug.js';
+import { isRecord } from './narrow.js';
 const SNIPPET_EXTENSIONS = { css: 'css', html: 'html', js: 'js', php: 'php', text: 'txt' };
 async function writeJson(path, value) {
     await mkdir(dirname(path), { recursive: true });
@@ -19,9 +22,20 @@ async function writeJson(path, value) {
 // compares (no `id`, no `description`, `code` with its `<?php` tag already stripped), exactly
 // what `normalizeSnippet` + `stripPhpOpeningTag` produce, so it plugs straight into the same
 // `buildSnippetFile`/`buildMetaFile` pair `snippet pull` uses to write files.
+// A snapshot entry that should be an object: anything else is a corrupted snapshot file.
+function snapshotRecord(id, value) {
+    if (!isRecord(value))
+        throw new Error(`Snapshot entry "${id}" is not an object.`);
+    return value;
+}
+const SNAPSHOT_OPTION = z.object({ autoload: z.string(), value: z.unknown() });
 async function snippet(id, value, dir) {
-    const fields = value;
-    const normalized = { ...fields, description: '', id: Number(id) };
+    const data = snapshotRecord(id, value);
+    // normalizeSnippet would coerce it, writing a corrupted entry's code over the live snippet.
+    if (typeof data.code !== 'string')
+        throw new Error(`Snapshot entry "${id}" has a non-string "code".`);
+    // normalizeSnippet is idempotent on its own output, so it narrows `data` without changing it.
+    const normalized = { ...normalizeSnippet(data), description: '', id: Number(id) };
     const ext = SNIPPET_EXTENSIONS[normalized.type];
     const base = `${normalized.id}-${toSlug(normalized.name)}`;
     await mkdir(dir, { recursive: true });
@@ -31,7 +45,7 @@ async function snippet(id, value, dir) {
 // value is the whole form JSON (minus `modified`/`modified_gmt`), the same shape `form pull`
 // writes verbatim; `form push` re-sends it as-is.
 async function form(id, value, dir) {
-    const data = value;
+    const data = snapshotRecord(id, value);
     const formId = getFormId(data) ?? Number(id);
     const slug = toSlug(getFormTitle(data), 'untitled');
     await writeJson(join(dir, `${formId}-${slug}.json`), data);
@@ -41,7 +55,7 @@ async function form(id, value, dir) {
 async function acf(id, value, dir) {
     const separator = id.indexOf('/');
     const type = id.slice(0, separator);
-    const data = value;
+    const data = snapshotRecord(id, value);
     const key = getAcfKey(data) ?? id.slice(separator + 1);
     await writeJson(join(dir, type, `${key}.json`), data);
 }
@@ -51,13 +65,18 @@ async function phpFile(id, value, dir) {
     await mkdir(dirname(filePath), { recursive: true });
     await writeFile(filePath, String(value));
 }
+// block: id is the slug, value the folder's files (file name => text).
+async function block(id, value, dir) {
+    const files = snapshotRecord(id, value);
+    await writeBlock(dir, { files: Object.fromEntries(Object.entries(files).map(([name, content]) => [name, String(content)])), slug: id });
+}
 // ids are 'menu-locations' or `menu/<slug>` (see resource-state.ts's menuProvider).
 async function menu(id, value, dir) {
     if (id === 'menu-locations') {
         await writeJson(join(dir, 'menu-locations.json'), value);
         return;
     }
-    const data = value;
+    const data = snapshotRecord(id, value);
     const slug = getMenuSlug(data) ?? id.slice('menu/'.length);
     await writeJson(join(dir, `${slug}.json`), data);
 }
@@ -67,7 +86,7 @@ async function menu(id, value, dir) {
 // dangerous option (siteurl, home, ...); defaulting to the same policy `option add` itself uses
 // keeps a rolled-back option exactly as protected as a freshly tracked one, never less.
 async function option(id, value, dir) {
-    const { autoload, value: optionValue } = value;
+    const { autoload, value: optionValue } = SNAPSHOT_OPTION.parse(value);
     const local = { autoload, name: id, readonly: defaultReadonlyFor(id), value: optionValue };
     await writeJson(join(dir, optionFileName(id)), local);
 }
@@ -79,12 +98,13 @@ async function themeStyles(id, value, dir) {
 // written in the spec's file format like `<resource> pull` does.
 function declaredType(spec) {
     return async (id, value, dir) => {
-        await writeFile(join(dir, `${id}${fileExtension(spec)}`), formatDeclaredFile(spec, value));
+        await writeFile(join(dir, `${id}${fileExtension(spec)}`), formatDeclaredFile(spec, snapshotRecord(id, value)));
     };
 }
 const MATERIALIZERS = {
     acf,
     api: phpFile,
+    block,
     cpt: declaredType(CPT_SPEC),
     form,
     hook: phpFile,
@@ -95,7 +115,7 @@ const MATERIALIZERS = {
     role: declaredType(ROLE_SPEC),
     snippet,
     taxonomy: declaredType(TAXONOMY_SPEC),
-    'theme-styles': themeStyles,
+    'theme-style': themeStyles,
 };
 // Writes a snapshot's state back to `dir` in the exact on-disk layout `<resource> pull` would
 // have produced, so the existing `<resource> push` command can push it unmodified: a rollback

package/dist/lib/rotate-app-password.js

@@ -1,3 +1,4 @@
+import {} from '../types/config.js';
 import { WpClient } from './wp-client.js';
 const APPLICATION_PASSWORDS_PATH = 'wp/v2/users/me/application-passwords';
 export const APP_PASSWORD_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;

package/dist/lib/sentry.js

@@ -20,8 +20,8 @@ export function runtimeContext() {
         os: `${platform()} ${release()}`,
     };
 }
-// Positional args and flag values can carry WordPress URLs, usernames, application passwords,
-// or tokens (e.g. `lps login --token xxx`, `lps project config <url>`). Only flag names are
+// Positional args and flag values are user input: environment names, local paths, slugs, and
+// anything else typed after a command, possibly a URL or a credential. Only flag names are
 // safe to report, they help tell which code path crashed without leaking what was passed to it.
 export function redactArgv(argv) {
     return argv.map((arg) => {

package/dist/lib/snapshot-store.d.ts

@@ -1,12 +1,14 @@
+import { z } from 'zod';
 import { type ResourceState } from './diff-state.js';
 export declare const SNAPSHOT_RETENTION = 10;
-export type Snapshot = {
-    afterState: Record<string, unknown>;
-    beforeState: Record<string, unknown>;
-    createdAt: string;
-    environment: string;
-    resource: string;
-};
+declare const SNAPSHOT: z.ZodObject<{
+    afterState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    beforeState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    environment: z.ZodString;
+    resource: z.ZodString;
+}, z.core.$strip>;
+export type Snapshot = z.infer<typeof SNAPSHOT>;
 export type SnapshotSummary = {
     createdAt: string;
     environment: string;
@@ -28,3 +30,4 @@ export declare function readSnapshot(rootDir: string, resource: string, environm
     id: string;
 }>;
 export declare function pruneSnapshots(rootDir: string, resource: string, environment: string, retain: number): Promise<void>;
+export {};

package/dist/lib/snapshot-store.js

@@ -1,8 +1,23 @@
 import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { z } from 'zod';
+import {} from './diff-state.js';
+import { errorCode } from './narrow.js';
 // How many snapshots `writeSnapshot` keeps per resource before pruning the oldest, so the
 // cache directory doesn't grow without bound across a project's lifetime.
 export const SNAPSHOT_RETENTION = 10;
+// One `lps <resource> push` recorded as a restore point. `beforeState` is the remote state
+// read immediately before that push (the "left" side `lps diff` would have shown); `afterState`
+// is the local state that was about to be pushed (the "right" side). Rolling back restores
+// `beforeState`; comparing the environment's *current* state against `afterState` at rollback
+// time is what detects whether anything else touched the environment since.
+const SNAPSHOT = z.object({
+    afterState: z.record(z.string(), z.unknown()),
+    beforeState: z.record(z.string(), z.unknown()),
+    createdAt: z.string(),
+    environment: z.string(),
+    resource: z.string(),
+});
 // `ResourceState` (a Map, for O(1) lookups during comparison) has no direct JSON
 // representation; snapshots round-trip through a plain object instead. Keys are sorted so two
 // snapshots of the same state serialize identically (stable diffs, deterministic tests).
@@ -27,10 +42,10 @@ function snapshotPath(rootDir, resource, environment, id) {
     return join(snapshotsDir(rootDir, resource, environment), `${id}.json`);
 }
 function isEnoent(error) {
-    return error.code === 'ENOENT';
+    return errorCode(error) === 'ENOENT';
 }
 function isEexist(error) {
-    return error.code === 'EEXIST';
+    return errorCode(error) === 'EEXIST';
 }
 // Snapshot ids are the millisecond timestamp they were written at: sortable, unique enough for
 // a single-machine CLI run, and directly usable as `--to <id>`.
@@ -105,7 +120,8 @@ export async function listSnapshots(rootDir, resource, environment) {
     for (const entry of snapshotFiles) {
         const id = entry.slice(0, -'.json'.length);
         try {
-            const parsed = JSON.parse(await readFile(join(dir, entry), 'utf8'));
+            const raw = JSON.parse(await readFile(join(dir, entry), 'utf8'));
+            const parsed = SNAPSHOT.parse(raw);
             summaries.push({ createdAt: parsed.createdAt, environment: parsed.environment, id, resource });
         }
         catch {
@@ -122,7 +138,7 @@ export async function listSnapshots(rootDir, resource, environment) {
 export async function readSnapshot(rootDir, resource, environment, id) {
     let targetId = id;
     if (targetId === undefined) {
-        const [latest] = await listSnapshots(rootDir, resource, environment);
+        const latest = (await listSnapshots(rootDir, resource, environment)).at(0);
         if (!latest) {
             throw new Error(`No snapshots found for "${resource}" on "${environment}". A snapshot is written automatically by \`lps ${resource} push\`.`);
         }
@@ -138,7 +154,7 @@ export async function readSnapshot(rootDir, resource, environment, id) {
         }
         throw error;
     }
-    return { ...JSON.parse(raw), id: targetId };
+    return { ...SNAPSHOT.parse(JSON.parse(raw)), id: targetId };
 }
 export async function pruneSnapshots(rootDir, resource, environment, retain) {
     const summaries = await listSnapshots(rootDir, resource, environment);

package/dist/lib/spinner.js

@@ -16,6 +16,7 @@ function start() {
     const rawOut = process.stdout.write;
     const rawErr = process.stderr.write;
     const draw = () => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typed as number, but undefined when stderr is not a TTY
         const text = `${FRAMES[frame]} ${label}`.slice(0, (process.stderr.columns ?? 80) - 1);
         rawErr.call(process.stderr, `\r\u{1B}[2K${text}`);
     };
@@ -26,7 +27,10 @@ function start() {
         draw();
         return result;
     };
+    // write() is overloaded, and a single rest-args wrapper can't be typed as every overload.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
     process.stdout.write = intercept(process.stdout, rawOut);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
     process.stderr.write = intercept(process.stderr, rawErr);
     draw();
     const timer = setInterval(() => {

package/dist/lib/validate-local.d.ts

@@ -6,5 +6,6 @@ export type ValidateResult = {
     checked: number;
     problems: Problem[];
     valid: boolean;
+    warnings: Problem[];
 };
 export declare function validateLocal(cwd: string): Promise<ValidateResult>;

package/dist/lib/validate-local.js

@@ -1,27 +1,34 @@
-import { readFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
+import { z } from 'zod';
 import { configManager } from '../config/project-config.manager.js';
+import { PLUGIN_PIN } from '../types/plugin.js';
+import { readLocalBlocks } from '../utils/block-format.js';
+import { COMPOSER_JSON } from '../utils/composer.js';
 import { CPT_SPEC, declaredFileChecker, META_SPEC, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC } from '../utils/declared-type-format.js';
 import { parseLocalOption } from '../utils/option-format.js';
 import { readLocalHtmlFiles, readLocalPages } from '../utils/page-format.js';
 import { RESOURCE_DIR_DEFAULTS } from '../utils/resource-dirs.js';
 import { parseType } from '../utils/snippet-format.js';
 import { readLocalTemplates } from '../utils/template-format.js';
+import { globToRegExp, matchesAny } from './exclude.js';
 import { loadSnippets } from './load-snippets.js';
+import { errorCode, errorMessage, isRecord } from './narrow.js';
 import { API_FILES_RESOURCE, HOOK_FILES_RESOURCE, phpFileProblems } from './php-files-command.js';
 import { readdirTolerant } from './readdir-tolerant.js';
 // Directories holding one JSON document per resource. Snippets (code file plus JSON sidecar)
 // and api routes (`.php`, not JSON) are checked separately, options too (a stricter shape).
-const JSON_RESOURCE_DIRS = ['acfDir', 'formDir', 'menuDir', 'themeStylesDir'];
+const JSON_RESOURCE_DIRS = ['acfDir', 'formDir', 'menuDir', 'themeStyleDir'];
 const DEFAULT_DIR = {
     acfDir: 'acf',
     apiDir: 'api',
+    blockDir: RESOURCE_DIR_DEFAULTS.block,
     cptDir: 'cpt',
     formDir: 'forms',
-    hooksDir: 'hooks',
+    hookDir: 'hooks',
     menuDir: 'menus',
     metaDir: 'meta',
-    optionsDir: 'options',
+    optionDir: 'options',
     pageDir: 'pages',
     partDir: RESOURCE_DIR_DEFAULTS.part,
     patternDir: RESOURCE_DIR_DEFAULTS.pattern,
@@ -29,7 +36,7 @@ const DEFAULT_DIR = {
     snippetsDir: 'snippets',
     taxonomyDir: 'taxonomies',
     templateDir: RESOURCE_DIR_DEFAULTS.template,
-    themeStylesDir: 'theme',
+    themeStyleDir: 'theme',
 };
 // Inspects the local tracked files under `cwd` without contacting WordPress: JSON files parse
 // and have the right shape, snippet sidecars use a known type, `loopress.json` points at a
@@ -52,7 +59,7 @@ export async function validateLocal(cwd) {
     }
     // Same reader `option push` uses: a file missing "name", "autoload" or "value" is skipped
     // there with a warning, so it's a problem here.
-    checked += await checkJsonDir(resolve('optionsDir'), problems, parseLocalOption);
+    checked += await checkJsonDir(resolve('optionDir'), problems, parseLocalOption);
     checked += await checkJsonDir(resolve('cptDir'), problems, declaredFileChecker(CPT_SPEC));
     checked += await checkJsonDir(resolve('taxonomyDir'), problems, declaredFileChecker(TAXONOMY_SPEC));
     checked += await checkJsonDir(resolve('metaDir'), problems, declaredFileChecker(META_SPEC));
@@ -60,14 +67,75 @@ export async function validateLocal(cwd) {
     checked += await checkPatterns(resolve('patternDir'), problems);
     checked += await checkSnippets(resolve('snippetsDir'), problems);
     checked += await checkPhpDir(resolve('apiDir'), problems, 'API route file is empty', API_FILES_RESOURCE);
-    checked += await checkPhpDir(resolve('hooksDir'), problems, 'Hook file is empty', HOOK_FILES_RESOURCE);
+    checked += await checkPhpDir(resolve('hookDir'), problems, 'Hook file is empty', HOOK_FILES_RESOURCE);
+    const blocks = await readLocalBlocks(resolve('blockDir'));
+    checked += blocks.blocks.length;
+    problems.push(...blocks.problems);
     const pages = await readLocalPages(resolve('pageDir'));
     checked += pages.pages.length + pages.problems.length;
     problems.push(...pages.problems);
     const templates = await readLocalTemplates(resolve('templateDir'), resolve('partDir'));
     checked += templates.templates.length + templates.parts.length + templates.problems.length;
     problems.push(...templates.problems);
-    return { checked, problems, valid: problems.length === 0 };
+    const warnings = await checkExcludes(localConfig, join(cwd, rootDir), problems);
+    return { checked, problems, valid: problems.length === 0, warnings };
+}
+// `environments.<name>.exclude` (lib/exclude.ts): a list of globs per environment. A glob that
+// matches no file is a warning, not a problem: likely a typo or a renamed file, so the feature it
+// was meant to hold back would reach that environment.
+async function checkExcludes(localConfig, root, problems) {
+    const { environments } = localConfig;
+    if (environments === undefined)
+        return [];
+    if (!isRecord(environments) || Array.isArray(environments)) {
+        problems.push({ file: 'loopress.json', message: '"environments" must be an object of environment name -> settings' });
+        return [];
+    }
+    const warnings = [];
+    let files;
+    for (const [name, settings] of Object.entries(environments)) {
+        const parsed = ENVIRONMENT_SETTINGS.safeParse(settings);
+        if (!parsed.success) {
+            problems.push({ file: 'loopress.json', message: `environments.${name} must be an object with an optional "exclude" list of glob strings` });
+            continue;
+        }
+        for (const pattern of parsed.data.exclude ?? []) {
+            files ??= await projectFiles(root);
+            const matcher = globToRegExp(pattern);
+            if (files.every((segments) => !matchesAny([matcher], segments))) {
+                warnings.push({ file: 'loopress.json', message: `environments.${name}.exclude: "${pattern}" matches no file` });
+            }
+        }
+    }
+    return warnings;
+}
+const ENVIRONMENT_SETTINGS = z.strictObject({ exclude: z.array(z.string()).optional() });
+// Every file under `root` as '/'-split segments, without node_modules and .git.
+async function projectFiles(root) {
+    const files = [];
+    const walk = async (dir) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name !== 'node_modules' && entry.name !== '.git')
+                    await walk(path);
+            }
+            else {
+                files.push(relative(root, path).split(sep));
+            }
+        }
+    };
+    await walk(root);
+    return files;
 }
 // Same directory rules as pages (flat, .html only), then the same checks as `pattern push`.
 async function checkPatterns(dir, problems) {
@@ -108,6 +176,7 @@ async function checkPhpDir(dir, problems, emptyMessage, spec) {
     }
     return checked;
 }
+const JSON_OBJECT = z.record(z.string(), z.unknown());
 async function checkComposerJson(cwd, problems) {
     let raw;
     try {
@@ -122,14 +191,13 @@ async function checkComposerJson(cwd, problems) {
         parsed = JSON.parse(raw);
     }
     catch (error) {
-        problems.push({ file: 'composer.json', message: `not valid JSON: ${error.message}` });
+        problems.push({ file: 'composer.json', message: `not valid JSON: ${errorMessage(error)}` });
         return 1;
     }
-    for (const key of ['require', 'require-dev']) {
-        const section = parsed[key];
-        if (section !== undefined && (typeof section !== 'object' || section === null || Array.isArray(section))) {
-            problems.push({ file: 'composer.json', message: `"${key}" must be an object` });
-        }
+    const result = COMPOSER_JSON.safeParse(parsed);
+    if (!result.success) {
+        for (const { message } of result.error.issues)
+            problems.push({ file: 'composer.json', message });
     }
     return 1;
 }
@@ -151,10 +219,10 @@ async function checkJsonDir(dir, problems, shape) {
             parsed = JSON.parse(raw);
         }
         catch (error) {
-            problems.push({ file: filePath, message: `not valid JSON: ${error.message}` });
+            problems.push({ file: filePath, message: `not valid JSON: ${errorMessage(error)}` });
             continue;
         }
-        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        if (!JSON_OBJECT.safeParse(parsed).success) {
             problems.push({ file: filePath, message: 'expected a JSON object' });
             continue;
         }
@@ -162,7 +230,7 @@ async function checkJsonDir(dir, problems, shape) {
             shape?.(raw, filePath);
         }
         catch (error) {
-            problems.push({ file: filePath, message: error.message });
+            problems.push({ file: filePath, message: errorMessage(error) });
         }
     }
     return checked;
@@ -184,19 +252,16 @@ function checkLoopressJson(localConfig, problems) {
     const { plugins } = localConfig;
     if (plugins === undefined)
         return;
-    if (typeof plugins !== 'object' || plugins === null || Array.isArray(plugins)) {
+    const manifest = JSON_OBJECT.safeParse(plugins);
+    if (!manifest.success) {
         problems.push({ file: 'loopress.json', message: '"plugins" must be an object of slug -> version string or {version, active}' });
         return;
     }
-    for (const [slug, version] of Object.entries(plugins)) {
+    for (const [slug, version] of Object.entries(manifest.data)) {
         // The object form is what `plugin pull` writes for a plugin installed but inactive (see PluginPin).
-        const isPin = typeof version === 'string' ||
-            (typeof version === 'object' &&
-                version !== null &&
-                typeof version.version === 'string' &&
-                ['boolean', 'undefined'].includes(typeof version.active));
-        if (!isPin)
+        if (!PLUGIN_PIN.safeParse(version).success) {
             problems.push({ file: 'loopress.json', message: `plugin "${slug}" must map to a version string or {version, active}` });
+        }
     }
 }
 async function checkSnippets(dir, problems) {
@@ -211,7 +276,7 @@ async function checkSnippets(dir, problems) {
         });
     }
     catch (error) {
-        problems.push({ file: dir, message: error.message });
+        problems.push({ file: dir, message: errorMessage(error) });
         return 0;
     }
     // loadSnippets coerces an invalid `type` to the extension default rather than failing, so
@@ -227,6 +292,10 @@ async function checkSnippets(dir, problems) {
             problems.push({ file: filePath, message: 'not valid JSON' });
             continue;
         }
+        if (!isRecord(meta)) {
+            problems.push({ file: filePath, message: 'expected a JSON object' });
+            continue;
+        }
         if (meta.type !== undefined && parseType(meta.type) === null) {
             problems.push({ file: filePath, message: `"type": ${JSON.stringify(meta.type)} is not one of css, html, js, php, text` });
         }
@@ -245,15 +314,20 @@ async function readConfig(cwd, problems) {
         raw = await readFile(join(cwd, 'loopress.json'), 'utf8');
     }
     catch (error) {
-        if (error.code === 'ENOENT')
+        if (errorCode(error) === 'ENOENT')
             return {};
         throw error;
     }
+    let parsed;
     try {
-        return JSON.parse(raw);
+        parsed = JSON.parse(raw);
     }
     catch {
         problems.push({ file: 'loopress.json', message: 'loopress.json is not valid JSON. Fix or delete it, then run `lps init` again.' });
         return {};
     }
+    if (isRecord(parsed) && !Array.isArray(parsed))
+        return parsed;
+    problems.push({ file: 'loopress.json', message: 'expected a JSON object' });
+    return {};
 }

package/dist/lib/wp-client.d.ts

@@ -7,8 +7,8 @@ export declare function assertSecureSiteUrl(siteUrl: string, environmentName: st
  * Paths are relative to `<site>/wp-json/`, e.g. `loopress/v1/snippets` or `wp/v2/plugins`.
  */
 export declare class WpClient {
-    private readonly siteUrl;
     private readonly client;
+    private readonly siteUrl;
     constructor(siteUrl: string, token: string, environmentName?: string);
     delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
     get<T>(path: string, options?: RequestOptions): Promise<T>;
@@ -24,9 +24,15 @@ type RequestOptions = {
 };
 export declare function isNotFoundError(error: unknown): boolean;
 export declare function isForbiddenError(error: unknown): boolean;
+export declare function isApplicationPasswordsDisabled(error: unknown): boolean;
 export declare function isApplicative404(error: unknown, marker: string): boolean;
 export declare function isConflictCode(error: unknown, code: string): boolean;
 export declare function isTimeoutError(error: unknown): boolean;
 export declare function isInvalidPageNumber(error: unknown): boolean;
+export declare function responseOf(error: unknown): {
+    body?: string | undefined;
+    statusCode?: number | undefined;
+};
+export declare function parseBody(body: string | undefined): Record<string, unknown>;
 export declare function formatWpError(error: unknown, url: string, timeoutMs?: number): string;
 export {};