import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { z } from 'zod';

type TargetKind = "local" | "rest" | "ssh" | "docker";
type CompanionStatus = {
    installed: boolean;
    enabled: boolean;
    version: string | null;
    capabilities: readonly string[];
    /**
     * The owner's one decision, read from the companion at handshake:
     * 'full' — the full-access toggle is ON, the whole power surface is open;
     * 'guarded' — toggle OFF, the companion refuses the power surface
     * server-side and the client mirrors that with its own guard.
     * Companions older than 2.24 do not send the field; it is then derived
     * from whether they advertise the execute_php capability, which those
     * versions only did when the same toggle was on.
     */
    accessMode?: "full" | "guarded";
} | null;
interface WpCliOpts {
    allowDestructive?: boolean;
    timeoutMs?: number;
    cwd?: string;
}
interface WpCliResult {
    exitCode: number;
    stdout: string;
    stderr: string;
    durationMs: number;
}
interface RestRequest {
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
    path: string;
    query?: Record<string, string | number | boolean>;
    body?: unknown;
    headers?: Record<string, string>;
}
interface RestResponse {
    status: number;
    body: unknown;
    headers: Record<string, string>;
}
interface FileWriteOpts {
    mode?: "overwrite" | "append";
    backup?: boolean;
    confirmUnsafePath?: boolean;
}
interface Target {
    readonly id: string;
    readonly kind: TargetKind;
    readonly siteurl: string;
    readonly wpVersion: string;
    readonly phpVersion?: string;
    readonly companion: CompanionStatus;
    wpCli(args: readonly string[], opts?: WpCliOpts): Promise<WpCliResult>;
    rest(req: RestRequest): Promise<RestResponse>;
    fileRead(path: string): Promise<{
        content: string;
        bytes: number;
        absolutePath: string;
    }>;
    fileWrite(path: string, content: string, opts?: FileWriteOpts): Promise<{
        bytesWritten: number;
        backupPath: string | null;
        absolutePath: string;
    }>;
    fileExists(path: string): Promise<boolean>;
    rootPath(): string;
    executePhp?(payload: string, opts: {
        timeoutMs?: number;
        confirm: true;
    }): Promise<unknown>;
    introspect?(scope: string, opts?: {
        includeValues?: boolean;
    }): Promise<unknown>;
    close(): Promise<void>;
}

/**
 * Production-host matcher. Patterns are glob-like with `*` wildcards.
 *
 *   "mysite.com"     → matches exactly mysite.com (any port)
 *   "*.mysite.com"   → matches subdomains
 *   "client-*"       → matches client-anything
 */
declare class ProdGuard {
    private readonly patterns;
    /** Hosts the site itself reported as production, added at connect time. */
    private readonly markedHosts;
    /**
     * Hosts whose companion reported guarded mode (full-access toggle OFF).
     * Armed regardless of any production signal — the owner chose the safe
     * subset, so the client blocks its risky tools with a clear error instead
     * of letting each call travel to the server just to collect a 403.
     */
    private readonly guardedHosts;
    /**
     * Hosts whose owner enabled full access on the companion. Outranks every
     * detection signal: the toggle is the owner's decision, and second-guessing
     * it would only divert writes onto ledger-less paths like execute-php.
     */
    private readonly fullAccessHosts;
    constructor(patterns: readonly string[]);
    /**
     * Arm the guard for a host the site declared production, so a target the
     * operator never listed in ROLEPOD_WPLAB_PROD_HOSTS is still protected.
     *
     * Folded into `matches()` rather than checked separately, so every existing
     * call site picks it up without change. Returns false when `siteurl` has no
     * parseable host.
     */
    markProduction(siteurl: string): boolean;
    /** Arm the guard because the companion reported guarded mode. */
    armGuarded(siteurl: string): boolean;
    /** Disarm the guard because the owner enabled full access. */
    disarm(siteurl: string): boolean;
    /** True when a write to `siteurl` would need an explicit confirm. */
    isArmedFor(siteurl: string): boolean;
    matches(siteurl: string): {
        matched: false;
    } | {
        matched: true;
        pattern: string;
    };
    enforce(siteurl: string): void;
    static fromEnv(): ProdGuard;
}

type ProdGuardReason = 
/** the site declared WP_ENVIRONMENT_TYPE=production */
"env_type"
/** siteurl matched ROLEPOD_WPLAB_PROD_HOSTS */
 | "host_pattern"
/** the companion reported is_production at pair time (pre-2.24 companions) */
 | "companion"
/** the companion reported guarded mode — full-access toggle OFF */
 | "guarded"
/** the owner enabled full access on the companion; guard deliberately off */
 | "full_access"
/** the signal is set to something other than production */
 | "not_production"
/** the signal is unset — guard stays disarmed */
 | "unset"
/** the probe could not run (no wp-cli reachable) — guard stays disarmed */
 | "probe_failed";
interface ProdGuardStatus {
    /** raw signal; `""` when unset, `null` when the probe failed */
    env_type: string | null;
    armed: boolean;
    reason: ProdGuardReason;
}

declare class TargetRegistry {
    private readonly entries;
    private readonly idleMs;
    private readonly prodGuard;
    constructor(idleMs?: number, prodGuard?: ProdGuard);
    /**
     * Every Target reaches the tool layer through get()/list(), so this is where
     * the catastrophic-command guard is applied and where the production guard
     * is armed. Doing both here means no connect path — including pairing and
     * alias reconnect — can forget to.
     *
     * `accessMode` comes from the companion and settles the guard without
     * probing: 'guarded' arms it (the owner kept the safe subset), 'full'
     * disarms it (the owner opened the power surface — the toggle is their
     * decision, and the server enforces it independently anyway). When absent
     * (no companion to ask: local, SSH, docker, bare REST) the legacy probe
     * path runs: WP_ENVIRONMENT_TYPE via wp-cli plus ROLEPOD_WPLAB_PROD_HOSTS.
     *
     * `assumeProduction` arms the guard without probing — used when a pre-2.24
     * companion reports `is_production` at pair time.
     *
     * Returns null when the registry was built without a ProdGuard (tests).
     */
    register(target: Target, opts?: {
        assumeProduction?: boolean;
        accessMode?: "full" | "guarded";
    }): Promise<ProdGuardStatus | null>;
    get(id: string): Target;
    list(): readonly Target[];
    closeAll(): Promise<void>;
    disconnect(id: string): Promise<void>;
    private armTimer;
}

interface CreateServerOptions {
    /** Skip transport bind — useful for unit tests that just want a wired Server instance. */
    withoutTransport?: boolean;
}
declare function createServer(opts?: CreateServerOptions): Promise<{
    server: Server;
    registry: TargetRegistry;
    shutdown: () => Promise<void>;
}>;

declare const ProfileConfigSchema: z.ZodObject<{
    profile: z.ZodDefault<z.ZodEnum<["strict", "personal", "power"]>>;
    production_hosts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    default_target_path: z.ZodOptional<z.ZodString>;
    companion: z.ZodDefault<z.ZodObject<{
        require_installed: z.ZodDefault<z.ZodBoolean>;
        session_ttl_seconds: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        require_installed: boolean;
        session_ttl_seconds: number;
    }, {
        require_installed?: boolean | undefined;
        session_ttl_seconds?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    profile: "strict" | "personal" | "power";
    production_hosts: string[];
    companion: {
        require_installed: boolean;
        session_ttl_seconds: number;
    };
    default_target_path?: string | undefined;
}, {
    profile?: "strict" | "personal" | "power" | undefined;
    production_hosts?: string[] | undefined;
    default_target_path?: string | undefined;
    companion?: {
        require_installed?: boolean | undefined;
        session_ttl_seconds?: number | undefined;
    } | undefined;
}>;
type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
declare function loadProfile(): ProfileConfig;

interface SshTargetOptions {
    host: string;
    user: string;
    port?: number;
    privateKeyPath?: string;
    password?: string;
    wpPath: string;
}

interface DockerTargetOptions {
    containerName: string;
    wpPath: string;
    /** Override default docker socket / host. Useful for remote docker. */
    dockerHost?: string;
    dockerSocketPath?: string;
}

interface Credential {
    /** Canonical hostname, e.g. "walnutztudio.com" (lowercase, no scheme, no port). */
    site: string;
    /** WP user login (not email). */
    username: string;
    /** WP Application Password. Never logged. Never serialized to artifacts. */
    appPassword: string;
    /** ISO 8601. */
    addedAt: string;
    /** ISO 8601, optional — runtime updates via `touch`. */
    lastUsedAt?: string;
}

type ConnectInput = {
    kind: "local";
    path: string;
} | {
    kind: "rest";
    url: string;
    credential: Credential;
} | {
    kind: "ssh";
    options: SshTargetOptions;
} | {
    kind: "docker";
    options: DockerTargetOptions;
};
declare function openTarget(input: ConnectInput): Promise<Target>;

declare class WplabError extends Error {
    readonly code: string;
    readonly meta: Record<string, unknown>;
    constructor(code: string, message: string, meta?: Record<string, unknown>);
    toJSON(): {
        code: string;
        message: string;
        meta: Record<string, unknown>;
    };
}
declare class TargetNotFoundError extends WplabError {
    constructor(targetId: string);
}
declare class WpCliNotFoundError extends WplabError {
    constructor();
}
declare class WpCliBlockedError extends WplabError {
    constructor(args: string[], reason: "not_in_allowlist" | "never_allowed");
}
declare class FsScopeError extends WplabError {
    constructor(path: string, reason: string);
}
declare class ProductionBlockedError extends WplabError {
    constructor(siteurl: string, matchedPattern: string);
}
declare class DbWriteBlockedError extends WplabError {
    constructor(sql: string);
}
/**
 * A tool that only works through the companion, called on a target without
 * one. Names the install and the reconnect so the model hands the user a
 * link instead of a dead end.
 */
declare class CompanionRequiredError extends WplabError {
    constructor(tool: string, targetId: string, why?: string);
}
declare class CompanionUnavailableError extends WplabError {
    constructor(targetId: string, detail: string, opts?: {
        installUrl?: string;
    });
}
declare class PowerProfileRequiredError extends WplabError {
    constructor();
}
declare class AstRejectedError extends WplabError {
    constructor(token: string, location: string);
}
/**
 * Thrown when the main companion namespace (wplab/v1) is unreachable but the
 * mu-plugin guardian namespace (wplab-recovery/v1) is alive. Surfaces last
 * fatal so the AI can call recovery tools (disable plugin/file, restore
 * snapshot) before retrying the original op.
 */
declare class RecoveryModeError extends WplabError {
    constructor(detail: {
        targetId: string;
        lastFatal: Record<string, unknown> | null;
        recentFatals: Array<Record<string, unknown>>;
        guardianVersion: string;
    });
}

type errors_AstRejectedError = AstRejectedError;
declare const errors_AstRejectedError: typeof AstRejectedError;
type errors_CompanionRequiredError = CompanionRequiredError;
declare const errors_CompanionRequiredError: typeof CompanionRequiredError;
type errors_CompanionUnavailableError = CompanionUnavailableError;
declare const errors_CompanionUnavailableError: typeof CompanionUnavailableError;
type errors_DbWriteBlockedError = DbWriteBlockedError;
declare const errors_DbWriteBlockedError: typeof DbWriteBlockedError;
type errors_FsScopeError = FsScopeError;
declare const errors_FsScopeError: typeof FsScopeError;
type errors_PowerProfileRequiredError = PowerProfileRequiredError;
declare const errors_PowerProfileRequiredError: typeof PowerProfileRequiredError;
type errors_ProductionBlockedError = ProductionBlockedError;
declare const errors_ProductionBlockedError: typeof ProductionBlockedError;
type errors_RecoveryModeError = RecoveryModeError;
declare const errors_RecoveryModeError: typeof RecoveryModeError;
type errors_TargetNotFoundError = TargetNotFoundError;
declare const errors_TargetNotFoundError: typeof TargetNotFoundError;
type errors_WpCliBlockedError = WpCliBlockedError;
declare const errors_WpCliBlockedError: typeof WpCliBlockedError;
type errors_WpCliNotFoundError = WpCliNotFoundError;
declare const errors_WpCliNotFoundError: typeof WpCliNotFoundError;
type errors_WplabError = WplabError;
declare const errors_WplabError: typeof WplabError;
declare namespace errors {
  export { errors_AstRejectedError as AstRejectedError, errors_CompanionRequiredError as CompanionRequiredError, errors_CompanionUnavailableError as CompanionUnavailableError, errors_DbWriteBlockedError as DbWriteBlockedError, errors_FsScopeError as FsScopeError, errors_PowerProfileRequiredError as PowerProfileRequiredError, errors_ProductionBlockedError as ProductionBlockedError, errors_RecoveryModeError as RecoveryModeError, errors_TargetNotFoundError as TargetNotFoundError, errors_WpCliBlockedError as WpCliBlockedError, errors_WpCliNotFoundError as WpCliNotFoundError, errors_WplabError as WplabError };
}

/**
 * target_id accepts either:
 *   - `tgt_<8+ lowercase hex>` — live session id from connect_rest/connect_local/pair
 *   - `@<alias>` — persistent alias configured via rolepod_wp_target_alias
 *     (resolved + auto-reconnected by the dispatcher before the handler runs)
 */
declare const TargetIdSchema: z.ZodString;
declare const RunIdSchema: z.ZodString;
/**
 * Production-guard state, resolved once at connect time. `armed: true` means
 * write tools on this target require `confirm=true`.
 */
declare const ProdGuardStatusSchema: z.ZodNullable<z.ZodObject<{
    armed: z.ZodBoolean;
    env_type: z.ZodNullable<z.ZodString>;
    reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
}, "strip", z.ZodTypeAny, {
    reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
    env_type: string | null;
    armed: boolean;
}, {
    reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
    env_type: string | null;
    armed: boolean;
}>>;
declare const ConnectLocalInputSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type ConnectLocalInput = z.infer<typeof ConnectLocalInputSchema>;
declare const ConnectLocalOutputSchema: z.ZodObject<{
    target_id: z.ZodString;
    siteurl: z.ZodString;
    wp_version: z.ZodString;
    php_version: z.ZodOptional<z.ZodString>;
    companion: z.ZodNullable<z.ZodObject<{
        installed: z.ZodBoolean;
        version: z.ZodNullable<z.ZodString>;
        capabilities: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        version: string | null;
        installed: boolean;
        capabilities: string[];
    }, {
        version: string | null;
        installed: boolean;
        capabilities: string[];
    }>>;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
}, "strip", z.ZodTypeAny, {
    companion: {
        version: string | null;
        installed: boolean;
        capabilities: string[];
    } | null;
    siteurl: string;
    wp_version: string;
    target_id: string;
    php_version?: string | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}, {
    companion: {
        version: string | null;
        installed: boolean;
        capabilities: string[];
    } | null;
    siteurl: string;
    wp_version: string;
    target_id: string;
    php_version?: string | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}>;
type ConnectLocalOutput = z.infer<typeof ConnectLocalOutputSchema>;
declare const ConnectRestInputSchema: z.ZodObject<{
    url: z.ZodEffects<z.ZodString, string, string>;
    credential_ref: z.ZodOptional<z.ZodString>;
    require_companion: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    url: string;
    require_companion: boolean;
    credential_ref?: string | undefined;
}, {
    url: string;
    credential_ref?: string | undefined;
    require_companion?: boolean | undefined;
}>;
type ConnectRestInput = z.infer<typeof ConnectRestInputSchema>;
declare const ConnectRestOutputSchema: z.ZodObject<{
    target_id: z.ZodString;
    siteurl: z.ZodString;
    wp_version: z.ZodString;
    php_version: z.ZodOptional<z.ZodString>;
    companion: z.ZodNullable<z.ZodObject<{
        installed: z.ZodBoolean;
        enabled: z.ZodBoolean;
        version: z.ZodNullable<z.ZodString>;
        capabilities: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        version: string | null;
        installed: boolean;
        enabled: boolean;
        capabilities: string[];
    }, {
        version: string | null;
        installed: boolean;
        enabled: boolean;
        capabilities: string[];
    }>>;
    profile: z.ZodOptional<z.ZodObject<{
        active: z.ZodEnum<["strict", "personal", "power"]>;
        execute_php_unlocked: z.ZodBoolean;
        env_var_name: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        active: "strict" | "personal" | "power";
        execute_php_unlocked: boolean;
        env_var_name: string;
    }, {
        active: "strict" | "personal" | "power";
        execute_php_unlocked: boolean;
        env_var_name: string;
    }>>;
    memory_summary: z.ZodOptional<z.ZodString>;
    warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        suggested_fix: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        code: string;
        message: string;
        suggested_fix?: string | undefined;
    }, {
        code: string;
        message: string;
        suggested_fix?: string | undefined;
    }>, "many">>;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
}, "strip", z.ZodTypeAny, {
    companion: {
        version: string | null;
        installed: boolean;
        enabled: boolean;
        capabilities: string[];
    } | null;
    siteurl: string;
    wp_version: string;
    target_id: string;
    profile?: {
        active: "strict" | "personal" | "power";
        execute_php_unlocked: boolean;
        env_var_name: string;
    } | undefined;
    php_version?: string | undefined;
    warnings?: {
        code: string;
        message: string;
        suggested_fix?: string | undefined;
    }[] | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
    memory_summary?: string | undefined;
}, {
    companion: {
        version: string | null;
        installed: boolean;
        enabled: boolean;
        capabilities: string[];
    } | null;
    siteurl: string;
    wp_version: string;
    target_id: string;
    profile?: {
        active: "strict" | "personal" | "power";
        execute_php_unlocked: boolean;
        env_var_name: string;
    } | undefined;
    php_version?: string | undefined;
    warnings?: {
        code: string;
        message: string;
        suggested_fix?: string | undefined;
    }[] | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
    memory_summary?: string | undefined;
}>;
type ConnectRestOutput = z.infer<typeof ConnectRestOutputSchema>;
declare const ConnectSshInputSchema: z.ZodObject<{
    host: z.ZodString;
    user: z.ZodString;
    wp_path: z.ZodString;
    port: z.ZodDefault<z.ZodNumber>;
    private_key_path: z.ZodOptional<z.ZodString>;
    password: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    host: string;
    port: number;
    user: string;
    wp_path: string;
    password?: string | undefined;
    private_key_path?: string | undefined;
}, {
    host: string;
    user: string;
    wp_path: string;
    port?: number | undefined;
    password?: string | undefined;
    private_key_path?: string | undefined;
}>;
type ConnectSshInput = z.infer<typeof ConnectSshInputSchema>;
declare const ConnectSshOutputSchema: z.ZodObject<{
    target_id: z.ZodString;
    siteurl: z.ZodString;
    wp_version: z.ZodString;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
}, "strip", z.ZodTypeAny, {
    siteurl: string;
    wp_version: string;
    target_id: string;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}, {
    siteurl: string;
    wp_version: string;
    target_id: string;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}>;
type ConnectSshOutput = z.infer<typeof ConnectSshOutputSchema>;
declare const ConnectDockerInputSchema: z.ZodObject<{
    container_name: z.ZodString;
    wp_path: z.ZodDefault<z.ZodString>;
    docker_host: z.ZodOptional<z.ZodString>;
    docker_socket_path: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    wp_path: string;
    container_name: string;
    docker_host?: string | undefined;
    docker_socket_path?: string | undefined;
}, {
    container_name: string;
    wp_path?: string | undefined;
    docker_host?: string | undefined;
    docker_socket_path?: string | undefined;
}>;
type ConnectDockerInput = z.infer<typeof ConnectDockerInputSchema>;
declare const ConnectDockerOutputSchema: z.ZodObject<{
    target_id: z.ZodString;
    siteurl: z.ZodString;
    wp_version: z.ZodString;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
}, "strip", z.ZodTypeAny, {
    siteurl: string;
    wp_version: string;
    target_id: string;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}, {
    siteurl: string;
    wp_version: string;
    target_id: string;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}>;
type ConnectDockerOutput = z.infer<typeof ConnectDockerOutputSchema>;
declare const DisconnectInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type DisconnectInput = z.infer<typeof DisconnectInputSchema>;
declare const DisconnectOutputSchema: z.ZodObject<{
    closed: z.ZodLiteral<true>;
}, "strip", z.ZodTypeAny, {
    closed: true;
}, {
    closed: true;
}>;
type DisconnectOutput = z.infer<typeof DisconnectOutputSchema>;
/**
 * Default cap on wp-cli output handed back to the model, per stream. 64 KiB
 * is roughly 16k tokens: room for a full `plugin list`, not enough for
 * `SELECT * FROM wp_posts` to take the whole context with it.
 */
declare const WP_CLI_OUTPUT_CAP_DEFAULT = 65536;
declare const WpCliRunInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    args: z.ZodArray<z.ZodString, "many">;
    allow_destructive: z.ZodDefault<z.ZodBoolean>;
    timeout_ms: z.ZodDefault<z.ZodNumber>;
    max_bytes: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    args: string[];
    target_id: string;
    allow_destructive: boolean;
    timeout_ms: number;
    max_bytes: number;
}, {
    args: string[];
    target_id: string;
    allow_destructive?: boolean | undefined;
    timeout_ms?: number | undefined;
    max_bytes?: number | undefined;
}>;
type WpCliRunInput = z.infer<typeof WpCliRunInputSchema>;
declare const WpCliRunOutputSchema: z.ZodObject<{
    total_bytes: z.ZodNumber;
    returned_bytes: z.ZodNumber;
    truncated: z.ZodBoolean;
    exit_code: z.ZodNumber;
    stdout: z.ZodString;
    stderr: z.ZodString;
    duration_ms: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    stdout: string;
    stderr: string;
    truncated: boolean;
    exit_code: number;
    duration_ms: number;
    total_bytes: number;
    returned_bytes: number;
}, {
    stdout: string;
    stderr: string;
    truncated: boolean;
    exit_code: number;
    duration_ms: number;
    total_bytes: number;
    returned_bytes: number;
}>;
type WpCliRunOutput = z.infer<typeof WpCliRunOutputSchema>;
declare const WpHealthCheckInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type WpHealthCheckInput = z.infer<typeof WpHealthCheckInputSchema>;
declare const WpHealthCheckOutputSchema: z.ZodObject<{
    wp_version: z.ZodString;
    php_version: z.ZodOptional<z.ZodString>;
    db_ok: z.ZodBoolean;
    wp_cli_ok: z.ZodBoolean;
    rest_ok: z.ZodBoolean;
    companion_ok: z.ZodBoolean;
    site_url: z.ZodString;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
    warnings: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    wp_version: string;
    warnings: string[];
    db_ok: boolean;
    wp_cli_ok: boolean;
    rest_ok: boolean;
    companion_ok: boolean;
    site_url: string;
    php_version?: string | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}, {
    wp_version: string;
    warnings: string[];
    db_ok: boolean;
    wp_cli_ok: boolean;
    rest_ok: boolean;
    companion_ok: boolean;
    site_url: string;
    php_version?: string | undefined;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}>;
type WpHealthCheckOutput = z.infer<typeof WpHealthCheckOutputSchema>;
declare const PostGetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    id: z.ZodNumber;
    context: z.ZodDefault<z.ZodEnum<["view", "edit", "embed"]>>;
    type: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: string;
    id: number;
    target_id: string;
    context: "view" | "edit" | "embed";
}, {
    id: number;
    target_id: string;
    type?: string | undefined;
    context?: "view" | "edit" | "embed" | undefined;
}>;
type PostGetInput = z.infer<typeof PostGetInputSchema>;
declare const PostGetOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    post: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    status: number;
    post?: unknown;
}, {
    status: number;
    post?: unknown;
}>;
type PostGetOutput = z.infer<typeof PostGetOutputSchema>;
declare const PostListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    type: z.ZodDefault<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
    search: z.ZodOptional<z.ZodString>;
    status: z.ZodOptional<z.ZodString>;
    orderby: z.ZodOptional<z.ZodString>;
    order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
}, "strip", z.ZodTypeAny, {
    type: string;
    target_id: string;
    per_page: number;
    page: number;
    status?: string | undefined;
    search?: string | undefined;
    orderby?: string | undefined;
    order?: "asc" | "desc" | undefined;
}, {
    target_id: string;
    type?: string | undefined;
    status?: string | undefined;
    search?: string | undefined;
    per_page?: number | undefined;
    page?: number | undefined;
    orderby?: string | undefined;
    order?: "asc" | "desc" | undefined;
}>;
type PostListInput = z.infer<typeof PostListInputSchema>;
declare const PostListOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    items: z.ZodArray<z.ZodUnknown, "many">;
    total: z.ZodOptional<z.ZodNumber>;
    total_pages: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status: number;
    items: unknown[];
    total?: number | undefined;
    total_pages?: number | undefined;
}, {
    status: number;
    items: unknown[];
    total?: number | undefined;
    total_pages?: number | undefined;
}>;
type PostListOutput = z.infer<typeof PostListOutputSchema>;
declare const PostCreateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    type: z.ZodDefault<z.ZodString>;
    title: z.ZodString;
    content: z.ZodString;
    status: z.ZodDefault<z.ZodEnum<["publish", "future", "draft", "pending", "private"]>>;
    excerpt: z.ZodOptional<z.ZodString>;
    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    categories: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    tags: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    featured_media: z.ZodOptional<z.ZodNumber>;
    slug: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: string;
    status: "publish" | "future" | "draft" | "pending" | "private";
    content: string;
    title: string;
    target_id: string;
    slug?: string | undefined;
    excerpt?: string | undefined;
    meta?: Record<string, unknown> | undefined;
    categories?: number[] | undefined;
    tags?: number[] | undefined;
    featured_media?: number | undefined;
}, {
    content: string;
    title: string;
    target_id: string;
    type?: string | undefined;
    status?: "publish" | "future" | "draft" | "pending" | "private" | undefined;
    slug?: string | undefined;
    excerpt?: string | undefined;
    meta?: Record<string, unknown> | undefined;
    categories?: number[] | undefined;
    tags?: number[] | undefined;
    featured_media?: number | undefined;
}>;
type PostCreateInput = z.infer<typeof PostCreateInputSchema>;
declare const PostCreateOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    id: z.ZodNumber;
    link: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: number;
    id: number;
    link?: string | undefined;
}, {
    status: number;
    id: number;
    link?: string | undefined;
}>;
type PostCreateOutput = z.infer<typeof PostCreateOutputSchema>;
declare const PostUpdateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    type: z.ZodDefault<z.ZodString>;
    id: z.ZodNumber;
    title: z.ZodOptional<z.ZodString>;
    content: z.ZodOptional<z.ZodString>;
    status: z.ZodOptional<z.ZodEnum<["publish", "future", "draft", "pending", "private"]>>;
    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    categories: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    tags: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    featured_media: z.ZodOptional<z.ZodNumber>;
    slug: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: string;
    id: number;
    target_id: string;
    status?: "publish" | "future" | "draft" | "pending" | "private" | undefined;
    content?: string | undefined;
    slug?: string | undefined;
    title?: string | undefined;
    meta?: Record<string, unknown> | undefined;
    categories?: number[] | undefined;
    tags?: number[] | undefined;
    featured_media?: number | undefined;
}, {
    id: number;
    target_id: string;
    type?: string | undefined;
    status?: "publish" | "future" | "draft" | "pending" | "private" | undefined;
    content?: string | undefined;
    slug?: string | undefined;
    title?: string | undefined;
    meta?: Record<string, unknown> | undefined;
    categories?: number[] | undefined;
    tags?: number[] | undefined;
    featured_media?: number | undefined;
}>;
type PostUpdateInput = z.infer<typeof PostUpdateInputSchema>;
declare const PostUpdateOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    id: z.ZodNumber;
    modified: z.ZodOptional<z.ZodString>;
    slug_changed_warning: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: number;
    id: number;
    modified?: string | undefined;
    slug_changed_warning?: string | undefined;
}, {
    status: number;
    id: number;
    modified?: string | undefined;
    slug_changed_warning?: string | undefined;
}>;
type PostUpdateOutput = z.infer<typeof PostUpdateOutputSchema>;
declare const OptionGetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    name: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    target_id: string;
}, {
    name: string;
    target_id: string;
}>;
type OptionGetInput = z.infer<typeof OptionGetInputSchema>;
declare const OptionGetOutputSchema: z.ZodObject<{
    name: z.ZodString;
    value: z.ZodUnknown;
    source: z.ZodEnum<["wp_cli", "rest_settings", "companion_option_get"]>;
}, "strip", z.ZodTypeAny, {
    name: string;
    source: "wp_cli" | "rest_settings" | "companion_option_get";
    value?: unknown;
}, {
    name: string;
    source: "wp_cli" | "rest_settings" | "companion_option_get";
    value?: unknown;
}>;
type OptionGetOutput = z.infer<typeof OptionGetOutputSchema>;
declare const OptionSetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    name: z.ZodString;
    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown, "many">]>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    value: string | number | boolean | Record<string, unknown> | unknown[];
    name: string;
    target_id: string;
    confirm: boolean;
}, {
    value: string | number | boolean | Record<string, unknown> | unknown[];
    name: string;
    target_id: string;
    confirm?: boolean | undefined;
}>;
type OptionSetInput = z.infer<typeof OptionSetInputSchema>;
declare const OptionSetOutputSchema: z.ZodObject<{
    name: z.ZodString;
    changed: z.ZodBoolean;
    source: z.ZodEnum<["wp_cli", "rest_settings", "companion_option_set"]>;
}, "strip", z.ZodTypeAny, {
    name: string;
    changed: boolean;
    source: "wp_cli" | "rest_settings" | "companion_option_set";
}, {
    name: string;
    changed: boolean;
    source: "wp_cli" | "rest_settings" | "companion_option_set";
}>;
type OptionSetOutput = z.infer<typeof OptionSetOutputSchema>;
declare const UserListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    per_page: z.ZodDefault<z.ZodNumber>;
    page: z.ZodDefault<z.ZodNumber>;
    search: z.ZodOptional<z.ZodString>;
    role: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    per_page: number;
    page: number;
    search?: string | undefined;
    role?: string | undefined;
}, {
    target_id: string;
    search?: string | undefined;
    per_page?: number | undefined;
    page?: number | undefined;
    role?: string | undefined;
}>;
type UserListInput = z.infer<typeof UserListInputSchema>;
declare const UserListOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    users: z.ZodArray<z.ZodUnknown, "many">;
}, "strip", z.ZodTypeAny, {
    status: number;
    users: unknown[];
}, {
    status: number;
    users: unknown[];
}>;
type UserListOutput = z.infer<typeof UserListOutputSchema>;
declare const DbQueryInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    sql: z.ZodString;
    allow_write: z.ZodDefault<z.ZodBoolean>;
    confirm: z.ZodDefault<z.ZodBoolean>;
    max_bytes: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    sql: string;
    target_id: string;
    max_bytes: number;
    confirm: boolean;
    allow_write: boolean;
}, {
    sql: string;
    target_id: string;
    max_bytes?: number | undefined;
    confirm?: boolean | undefined;
    allow_write?: boolean | undefined;
}>;
type DbQueryInput = z.infer<typeof DbQueryInputSchema>;
declare const DbQueryOutputSchema: z.ZodObject<{
    total_bytes: z.ZodNumber;
    returned_bytes: z.ZodNumber;
    truncated: z.ZodBoolean;
    rows: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
    stdout: z.ZodString;
    stderr: z.ZodString;
    exit_code: z.ZodNumber;
    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    stdout: string;
    stderr: string;
    truncated: boolean;
    exit_code: number;
    total_bytes: number;
    returned_bytes: number;
    rows?: Record<string, unknown>[] | undefined;
    warnings?: string[] | undefined;
}, {
    stdout: string;
    stderr: string;
    truncated: boolean;
    exit_code: number;
    total_bytes: number;
    returned_bytes: number;
    rows?: Record<string, unknown>[] | undefined;
    warnings?: string[] | undefined;
}>;
type DbQueryOutput = z.infer<typeof DbQueryOutputSchema>;
declare const RestRequestInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
    path: z.ZodString;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
    body: z.ZodOptional<z.ZodUnknown>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    path: string;
    target_id: string;
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
    body?: unknown;
    headers?: Record<string, string> | undefined;
    query?: Record<string, string | number | boolean> | undefined;
}, {
    path: string;
    target_id: string;
    body?: unknown;
    headers?: Record<string, string> | undefined;
    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | undefined;
    query?: Record<string, string | number | boolean> | undefined;
}>;
type RestRequestInput = z.infer<typeof RestRequestInputSchema>;
declare const RestRequestOutputSchema: z.ZodObject<{
    status: z.ZodNumber;
    body: z.ZodUnknown;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: number;
    headers: Record<string, string>;
    body?: unknown;
}, {
    status: number;
    headers: Record<string, string>;
    body?: unknown;
}>;
type RestRequestOutput = z.infer<typeof RestRequestOutputSchema>;
declare const ScaffoldBlockInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    plugin_slug: z.ZodString;
    block_slug: z.ZodString;
    title: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    category: z.ZodDefault<z.ZodString>;
    icon: z.ZodDefault<z.ZodString>;
    render_strategy: z.ZodDefault<z.ZodEnum<["dynamic", "static"]>>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    category: string;
    title: string;
    target_id: string;
    allow_destructive: true;
    plugin_slug: string;
    block_slug: string;
    icon: string;
    render_strategy: "dynamic" | "static";
    description?: string | undefined;
}, {
    title: string;
    target_id: string;
    allow_destructive: true | "true";
    plugin_slug: string;
    block_slug: string;
    category?: string | undefined;
    description?: string | undefined;
    icon?: string | undefined;
    render_strategy?: "dynamic" | "static" | undefined;
}>;
type ScaffoldBlockInput = z.infer<typeof ScaffoldBlockInputSchema>;
declare const ScaffoldBlockOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    files_written: z.ZodArray<z.ZodString, "many">;
    next_steps: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    files_written: string[];
    next_steps: string[];
}, {
    run_id: string;
    files_written: string[];
    next_steps: string[];
}>;
type ScaffoldBlockOutput = z.infer<typeof ScaffoldBlockOutputSchema>;
declare const ScaffoldPluginInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    author: z.ZodDefault<z.ZodString>;
    features: z.ZodDefault<z.ZodArray<z.ZodEnum<["rest_endpoint", "admin_page", "gutenberg_block", "cli_command"]>, "many">>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    name: string;
    slug: string;
    target_id: string;
    allow_destructive: true;
    author: string;
    features: ("rest_endpoint" | "admin_page" | "gutenberg_block" | "cli_command")[];
    description?: string | undefined;
}, {
    name: string;
    slug: string;
    target_id: string;
    allow_destructive: true | "true";
    description?: string | undefined;
    author?: string | undefined;
    features?: ("rest_endpoint" | "admin_page" | "gutenberg_block" | "cli_command")[] | undefined;
}>;
type ScaffoldPluginInput = z.infer<typeof ScaffoldPluginInputSchema>;
declare const ScaffoldPluginOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    plugin_path: z.ZodString;
    files_written: z.ZodArray<z.ZodString, "many">;
    activate_command: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    files_written: string[];
    plugin_path: string;
    activate_command: string;
}, {
    run_id: string;
    files_written: string[];
    plugin_path: string;
    activate_command: string;
}>;
type ScaffoldPluginOutput = z.infer<typeof ScaffoldPluginOutputSchema>;
declare const ScaffoldThemeInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    author: z.ZodDefault<z.ZodString>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    name: string;
    slug: string;
    target_id: string;
    allow_destructive: true;
    author: string;
    description?: string | undefined;
}, {
    name: string;
    slug: string;
    target_id: string;
    allow_destructive: true | "true";
    description?: string | undefined;
    author?: string | undefined;
}>;
type ScaffoldThemeInput = z.infer<typeof ScaffoldThemeInputSchema>;
declare const ScaffoldThemeOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    theme_path: z.ZodString;
    files_written: z.ZodArray<z.ZodString, "many">;
    activate_command: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    files_written: string[];
    activate_command: string;
    theme_path: string;
}, {
    run_id: string;
    files_written: string[];
    activate_command: string;
    theme_path: string;
}>;
type ScaffoldThemeOutput = z.infer<typeof ScaffoldThemeOutputSchema>;
declare const AuditSecurityInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    report_format: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    report_format: "json" | "markdown";
}, {
    target_id: string;
    report_format?: "json" | "markdown" | undefined;
}>;
type AuditSecurityInput = z.infer<typeof AuditSecurityInputSchema>;
declare const AuditSecurityOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    wp_core_outdated: z.ZodBoolean;
    outdated_plugins: z.ZodArray<z.ZodObject<{
        slug: z.ZodString;
        current: z.ZodString;
        latest: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        current: string;
        slug: string;
        latest: string;
    }, {
        current: string;
        slug: string;
        latest: string;
    }>, "many">;
    outdated_themes: z.ZodArray<z.ZodObject<{
        slug: z.ZodString;
        current: z.ZodString;
        latest: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        current: string;
        slug: string;
        latest: string;
    }, {
        current: string;
        slug: string;
        latest: string;
    }>, "many">;
    weak_admin_users: z.ZodArray<z.ZodObject<{
        login: z.ZodString;
        reason: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        reason: string;
        login: string;
    }, {
        reason: string;
        login: string;
    }>, "many">;
    wp_debug_on: z.ZodBoolean;
    report_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    wp_core_outdated: boolean;
    outdated_plugins: {
        current: string;
        slug: string;
        latest: string;
    }[];
    outdated_themes: {
        current: string;
        slug: string;
        latest: string;
    }[];
    weak_admin_users: {
        reason: string;
        login: string;
    }[];
    wp_debug_on: boolean;
    report_path: string;
}, {
    run_id: string;
    wp_core_outdated: boolean;
    outdated_plugins: {
        current: string;
        slug: string;
        latest: string;
    }[];
    outdated_themes: {
        current: string;
        slug: string;
        latest: string;
    }[];
    weak_admin_users: {
        reason: string;
        login: string;
    }[];
    wp_debug_on: boolean;
    report_path: string;
}>;
type AuditSecurityOutput = z.infer<typeof AuditSecurityOutputSchema>;
declare const MigrateDryrunInputSchema: z.ZodObject<{
    source_target_id: z.ZodString;
    dest_target_id: z.ZodString;
    scope: z.ZodDefault<z.ZodArray<z.ZodEnum<["posts", "options", "users", "plugin_versions"]>, "many">>;
}, "strip", z.ZodTypeAny, {
    scope: ("options" | "posts" | "users" | "plugin_versions")[];
    source_target_id: string;
    dest_target_id: string;
}, {
    source_target_id: string;
    dest_target_id: string;
    scope?: ("options" | "posts" | "users" | "plugin_versions")[] | undefined;
}>;
type MigrateDryrunInput = z.infer<typeof MigrateDryrunInputSchema>;
declare const MigrateDryrunOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    plan: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    plan_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    plan: Record<string, unknown>;
    plan_path: string;
}, {
    run_id: string;
    plan: Record<string, unknown>;
    plan_path: string;
}>;
type MigrateDryrunOutput = z.infer<typeof MigrateDryrunOutputSchema>;
declare const AuditManyInputSchema: z.ZodObject<{
    target_ids: z.ZodArray<z.ZodString, "many">;
    report_format: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
}, "strip", z.ZodTypeAny, {
    report_format: "json" | "markdown";
    target_ids: string[];
}, {
    target_ids: string[];
    report_format?: "json" | "markdown" | undefined;
}>;
type AuditManyInput = z.infer<typeof AuditManyInputSchema>;
declare const AuditManyOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    reports: z.ZodArray<z.ZodObject<{
        target_id: z.ZodString;
        siteurl: z.ZodString;
        ok: z.ZodBoolean;
        error: z.ZodOptional<z.ZodString>;
        report_path: z.ZodOptional<z.ZodString>;
        summary: z.ZodOptional<z.ZodObject<{
            wp_core_outdated: z.ZodBoolean;
            outdated_plugin_count: z.ZodNumber;
            outdated_theme_count: z.ZodNumber;
            weak_admin_count: z.ZodNumber;
            wp_debug_on: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        }, {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        siteurl: string;
        ok: boolean;
        target_id: string;
        error?: string | undefined;
        report_path?: string | undefined;
        summary?: {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        } | undefined;
    }, {
        siteurl: string;
        ok: boolean;
        target_id: string;
        error?: string | undefined;
        report_path?: string | undefined;
        summary?: {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        } | undefined;
    }>, "many">;
    consolidated_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    reports: {
        siteurl: string;
        ok: boolean;
        target_id: string;
        error?: string | undefined;
        report_path?: string | undefined;
        summary?: {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        } | undefined;
    }[];
    consolidated_path: string;
}, {
    run_id: string;
    reports: {
        siteurl: string;
        ok: boolean;
        target_id: string;
        error?: string | undefined;
        report_path?: string | undefined;
        summary?: {
            wp_core_outdated: boolean;
            wp_debug_on: boolean;
            outdated_plugin_count: number;
            outdated_theme_count: number;
            weak_admin_count: number;
        } | undefined;
    }[];
    consolidated_path: string;
}>;
type AuditManyOutput = z.infer<typeof AuditManyOutputSchema>;
declare const MigrateDataInputSchema: z.ZodObject<{
    source_target_id: z.ZodString;
    dest_target_id: z.ZodString;
    scope: z.ZodDefault<z.ZodEnum<["plugin_versions", "options", "users", "posts"]>>;
    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    scope: "options" | "posts" | "users" | "plugin_versions";
    allow_destructive: true;
    confirm: boolean;
    source_target_id: string;
    dest_target_id: string;
    options?: string[] | undefined;
}, {
    allow_destructive: true | "true";
    source_target_id: string;
    dest_target_id: string;
    options?: string[] | undefined;
    scope?: "options" | "posts" | "users" | "plugin_versions" | undefined;
    confirm?: boolean | undefined;
}>;
type MigrateDataInput = z.infer<typeof MigrateDataInputSchema>;
declare const MigrateDataOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    scope: z.ZodString;
    applied: z.ZodArray<z.ZodUnion<[z.ZodObject<{
        action: z.ZodEnum<["install", "upgrade", "downgrade", "noop"]>;
        slug: z.ZodString;
        from: z.ZodOptional<z.ZodString>;
        to: z.ZodString;
        ok: z.ZodBoolean;
        error: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        ok: boolean;
        to: string;
        slug: string;
        action: "install" | "upgrade" | "downgrade" | "noop";
        error?: string | undefined;
        from?: string | undefined;
    }, {
        ok: boolean;
        to: string;
        slug: string;
        action: "install" | "upgrade" | "downgrade" | "noop";
        error?: string | undefined;
        from?: string | undefined;
    }>, z.ZodObject<{
        action: z.ZodLiteral<"option_set">;
        option: z.ZodString;
        ok: z.ZodBoolean;
        error: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        ok: boolean;
        option: string;
        action: "option_set";
        error?: string | undefined;
    }, {
        ok: boolean;
        option: string;
        action: "option_set";
        error?: string | undefined;
    }>]>, "many">;
    report_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    scope: string;
    applied: ({
        ok: boolean;
        to: string;
        slug: string;
        action: "install" | "upgrade" | "downgrade" | "noop";
        error?: string | undefined;
        from?: string | undefined;
    } | {
        ok: boolean;
        option: string;
        action: "option_set";
        error?: string | undefined;
    })[];
    run_id: string;
    report_path: string;
}, {
    scope: string;
    applied: ({
        ok: boolean;
        to: string;
        slug: string;
        action: "install" | "upgrade" | "downgrade" | "noop";
        error?: string | undefined;
        from?: string | undefined;
    } | {
        ok: boolean;
        option: string;
        action: "option_set";
        error?: string | undefined;
    })[];
    run_id: string;
    report_path: string;
}>;
type MigrateDataOutput = z.infer<typeof MigrateDataOutputSchema>;
declare const ExecutePhpInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    payload: z.ZodString;
    timeout_ms: z.ZodDefault<z.ZodNumber>;
    confirm: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    timeout_ms: number;
    confirm: true;
    payload: string;
}, {
    target_id: string;
    confirm: true | "true";
    payload: string;
    timeout_ms?: number | undefined;
}>;
type ExecutePhpInput = z.infer<typeof ExecutePhpInputSchema>;
declare const ExecutePhpOutputSchema: z.ZodObject<{
    ok: z.ZodBoolean;
    return_value: z.ZodOptional<z.ZodUnknown>;
    stdout: z.ZodOptional<z.ZodString>;
    duration_ms: z.ZodOptional<z.ZodNumber>;
    php_warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    audit_id: z.ZodString;
    error_message: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    ok: boolean;
    audit_id: string;
    stdout?: string | undefined;
    error_message?: string | undefined;
    duration_ms?: number | undefined;
    return_value?: unknown;
    php_warnings?: string[] | undefined;
}, {
    ok: boolean;
    audit_id: string;
    stdout?: string | undefined;
    error_message?: string | undefined;
    duration_ms?: number | undefined;
    return_value?: unknown;
    php_warnings?: string[] | undefined;
}>;
type ExecutePhpOutput = z.infer<typeof ExecutePhpOutputSchema>;
declare const SkillCatalogInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type SkillCatalogInput = z.infer<typeof SkillCatalogInputSchema>;
declare const SkillCatalogOutputSchema: z.ZodObject<{
    skills: z.ZodArray<z.ZodObject<{
        slug: z.ZodString;
        name: z.ZodString;
        description: z.ZodString;
        enable_agentic: z.ZodBoolean;
        enable_prompt: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        name: string;
        slug: string;
        description: string;
        enable_agentic: boolean;
        enable_prompt: boolean;
    }, {
        name: string;
        slug: string;
        description: string;
        enable_agentic: boolean;
        enable_prompt: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    skills: {
        name: string;
        slug: string;
        description: string;
        enable_agentic: boolean;
        enable_prompt: boolean;
    }[];
}, {
    skills: {
        name: string;
        slug: string;
        description: string;
        enable_agentic: boolean;
        enable_prompt: boolean;
    }[];
}>;
type SkillCatalogOutput = z.infer<typeof SkillCatalogOutputSchema>;
declare const SkillGetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
}, "strip", z.ZodTypeAny, {
    slug: string;
    target_id: string;
}, {
    slug: string;
    target_id: string;
}>;
type SkillGetInput = z.infer<typeof SkillGetInputSchema>;
declare const SkillGetOutputSchema: z.ZodObject<{
    found: z.ZodBoolean;
    slug: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    content: z.ZodOptional<z.ZodString>;
    skill_md: z.ZodOptional<z.ZodString>;
    enable_agentic: z.ZodOptional<z.ZodBoolean>;
    enable_prompt: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    found: boolean;
    name?: string | undefined;
    content?: string | undefined;
    slug?: string | undefined;
    description?: string | undefined;
    skill_md?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}, {
    found: boolean;
    name?: string | undefined;
    content?: string | undefined;
    slug?: string | undefined;
    description?: string | undefined;
    skill_md?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}>;
type SkillGetOutput = z.infer<typeof SkillGetOutputSchema>;
declare const SkillWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    title: z.ZodString;
    description: z.ZodDefault<z.ZodString>;
    content: z.ZodString;
    enable_agentic: z.ZodOptional<z.ZodBoolean>;
    enable_prompt: z.ZodOptional<z.ZodBoolean>;
    on_conflict: z.ZodDefault<z.ZodEnum<["fail", "replace", "rename"]>>;
}, "strip", z.ZodTypeAny, {
    content: string;
    description: string;
    title: string;
    on_conflict: "replace" | "fail" | "rename";
    target_id: string;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}, {
    content: string;
    title: string;
    target_id: string;
    description?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
    on_conflict?: "replace" | "fail" | "rename" | undefined;
}>;
type SkillWriteInput = z.infer<typeof SkillWriteInputSchema>;
declare const SkillWriteOutputSchema: z.ZodObject<{
    slug: z.ZodString;
    action: z.ZodString;
    warnings: z.ZodArray<z.ZodString, "many">;
    audit_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    audit_id: string;
    slug: string;
    action: string;
    warnings: string[];
}, {
    audit_id: string;
    slug: string;
    action: string;
    warnings: string[];
}>;
type SkillWriteOutput = z.infer<typeof SkillWriteOutputSchema>;
declare const SkillEditInputSchema: z.ZodEffects<z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    content: z.ZodOptional<z.ZodString>;
    enable_agentic: z.ZodOptional<z.ZodBoolean>;
    enable_prompt: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    slug: string;
    target_id: string;
    content?: string | undefined;
    description?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}, {
    slug: string;
    target_id: string;
    content?: string | undefined;
    description?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}>, {
    slug: string;
    target_id: string;
    content?: string | undefined;
    description?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}, {
    slug: string;
    target_id: string;
    content?: string | undefined;
    description?: string | undefined;
    enable_agentic?: boolean | undefined;
    enable_prompt?: boolean | undefined;
}>;
type SkillEditInput = z.infer<typeof SkillEditInputSchema>;
declare const SkillEditOutputSchema: z.ZodObject<{
    slug: z.ZodString;
    action: z.ZodString;
    skill: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    audit_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    audit_id: string;
    slug: string;
    action: string;
    skill?: unknown;
}, {
    audit_id: string;
    slug: string;
    action: string;
    skill?: unknown;
}>;
type SkillEditOutput = z.infer<typeof SkillEditOutputSchema>;
declare const SkillDeleteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
}, "strip", z.ZodTypeAny, {
    slug: string;
    target_id: string;
}, {
    slug: string;
    target_id: string;
}>;
type SkillDeleteInput = z.infer<typeof SkillDeleteInputSchema>;
declare const SkillDeleteOutputSchema: z.ZodObject<{
    slug: z.ZodString;
    action: z.ZodString;
    recoverable: z.ZodBoolean;
    audit_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    audit_id: string;
    slug: string;
    action: string;
    recoverable: boolean;
}, {
    audit_id: string;
    slug: string;
    action: string;
    recoverable: boolean;
}>;
type SkillDeleteOutput = z.infer<typeof SkillDeleteOutputSchema>;
declare const IntrospectInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["hooks", "transients", "options_full", "request_state"]>;
    include_values: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    scope: "hooks" | "transients" | "options_full" | "request_state";
    include_values: boolean;
    target_id: string;
}, {
    scope: "hooks" | "transients" | "options_full" | "request_state";
    target_id: string;
    include_values?: boolean | undefined;
}>;
type IntrospectInput = z.infer<typeof IntrospectInputSchema>;
declare const IntrospectOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    report: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    scope: string;
    report?: unknown;
}, {
    scope: string;
    report?: unknown;
}>;
type IntrospectOutput = z.infer<typeof IntrospectOutputSchema>;
declare const HookStateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    hook: z.ZodString;
    kind: z.ZodDefault<z.ZodEnum<["action", "filter"]>>;
}, "strip", z.ZodTypeAny, {
    kind: "filter" | "action";
    target_id: string;
    hook: string;
}, {
    target_id: string;
    hook: string;
    kind?: "filter" | "action" | undefined;
}>;
type HookStateInput = z.infer<typeof HookStateInputSchema>;
declare const HookStateOutputSchema: z.ZodObject<{
    hook: z.ZodString;
    kind: z.ZodEnum<["action", "filter"]>;
    callbacks: z.ZodArray<z.ZodObject<{
        priority: z.ZodNumber;
        callback_identifier: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        priority: number;
        callback_identifier: string;
    }, {
        priority: number;
        callback_identifier: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    kind: "filter" | "action";
    hook: string;
    callbacks: {
        priority: number;
        callback_identifier: string;
    }[];
}, {
    kind: "filter" | "action";
    hook: string;
    callbacks: {
        priority: number;
        callback_identifier: string;
    }[];
}>;
type HookStateOutput = z.infer<typeof HookStateOutputSchema>;
declare const MemoryRecallInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    query: z.ZodOptional<z.ZodString>;
    kind: z.ZodDefault<z.ZodEnum<["note", "convention", "runbook", "all"]>>;
}, "strip", z.ZodTypeAny, {
    kind: "all" | "note" | "convention" | "runbook";
    target_id: string;
    query?: string | undefined;
}, {
    target_id: string;
    kind?: "all" | "note" | "convention" | "runbook" | undefined;
    query?: string | undefined;
}>;
type MemoryRecallInput = z.infer<typeof MemoryRecallInputSchema>;
declare const MemoryRecallOutputSchema: z.ZodObject<{
    site_slug: z.ZodString;
    summary: z.ZodString;
    notes: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<["note", "convention", "runbook"]>;
        name: z.ZodString;
        content: z.ZodString;
        written_at: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        kind: "note" | "convention" | "runbook";
        name: string;
        content: string;
        written_at: string;
    }, {
        kind: "note" | "convention" | "runbook";
        name: string;
        content: string;
        written_at: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    summary: string;
    site_slug: string;
    notes: {
        kind: "note" | "convention" | "runbook";
        name: string;
        content: string;
        written_at: string;
    }[];
}, {
    summary: string;
    site_slug: string;
    notes: {
        kind: "note" | "convention" | "runbook";
        name: string;
        content: string;
        written_at: string;
    }[];
}>;
type MemoryRecallOutput = z.infer<typeof MemoryRecallOutputSchema>;
declare const MemoryNoteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    content: z.ZodString;
    kind: z.ZodDefault<z.ZodEnum<["note", "convention", "runbook"]>>;
    runbook_name: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    kind: "note" | "convention" | "runbook";
    content: string;
    target_id: string;
    tags?: string[] | undefined;
    runbook_name?: string | undefined;
}, {
    content: string;
    target_id: string;
    kind?: "note" | "convention" | "runbook" | undefined;
    tags?: string[] | undefined;
    runbook_name?: string | undefined;
}>;
type MemoryNoteInput = z.infer<typeof MemoryNoteInputSchema>;
declare const MemoryNoteOutputSchema: z.ZodObject<{
    saved_at: z.ZodString;
    file_path: z.ZodString;
    site_slug: z.ZodString;
}, "strip", z.ZodTypeAny, {
    site_slug: string;
    saved_at: string;
    file_path: string;
}, {
    site_slug: string;
    saved_at: string;
    file_path: string;
}>;
type MemoryNoteOutput = z.infer<typeof MemoryNoteOutputSchema>;
declare const MemoryListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type MemoryListInput = z.infer<typeof MemoryListInputSchema>;
declare const MemoryListOutputSchema: z.ZodObject<{
    site_slug: z.ZodString;
    files: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<["meta", "site", "note", "convention", "runbook"]>;
        name: z.ZodString;
        size_bytes: z.ZodNumber;
        mtime: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        kind: "site" | "meta" | "note" | "convention" | "runbook";
        name: string;
        mtime: string;
        size_bytes: number;
    }, {
        kind: "site" | "meta" | "note" | "convention" | "runbook";
        name: string;
        mtime: string;
        size_bytes: number;
    }>, "many">;
    total_bytes: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    total_bytes: number;
    site_slug: string;
    files: {
        kind: "site" | "meta" | "note" | "convention" | "runbook";
        name: string;
        mtime: string;
        size_bytes: number;
    }[];
}, {
    total_bytes: number;
    site_slug: string;
    files: {
        kind: "site" | "meta" | "note" | "convention" | "runbook";
        name: string;
        mtime: string;
        size_bytes: number;
    }[];
}>;
type MemoryListOutput = z.infer<typeof MemoryListOutputSchema>;
declare const ElementorReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    page_id: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
    kit: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: string;
    target_id: string;
    per_page: number;
    kit: boolean;
    page_id?: number | undefined;
}, {
    target_id: string;
    type?: string | undefined;
    per_page?: number | undefined;
    page_id?: number | undefined;
    kit?: boolean | undefined;
}>;
type ElementorReadInput = z.infer<typeof ElementorReadInputSchema>;
declare const ElementorReadOutputSchema: z.ZodObject<{
    mode: z.ZodEnum<["list", "page", "kit"]>;
    detected: z.ZodBoolean;
    pages: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    page: z.ZodOptional<z.ZodUnknown>;
    kit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    mode: "page" | "kit" | "list";
    detected: boolean;
    page?: unknown;
    kit?: Record<string, unknown> | undefined;
    pages?: unknown[] | undefined;
}, {
    mode: "page" | "kit" | "list";
    detected: boolean;
    page?: unknown;
    kit?: Record<string, unknown> | undefined;
    pages?: unknown[] | undefined;
}>;
type ElementorReadOutput = z.infer<typeof ElementorReadOutputSchema>;
declare const WooReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["products", "orders", "settings_groups", "settings_in_group", "shipping_zones", "payment_gateways"]>;
    group: z.ZodOptional<z.ZodString>;
    per_page: z.ZodOptional<z.ZodNumber>;
    search: z.ZodOptional<z.ZodString>;
    status: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    scope: "products" | "orders" | "settings_groups" | "settings_in_group" | "shipping_zones" | "payment_gateways";
    target_id: string;
    status?: string | undefined;
    search?: string | undefined;
    per_page?: number | undefined;
    group?: string | undefined;
}, {
    scope: "products" | "orders" | "settings_groups" | "settings_in_group" | "shipping_zones" | "payment_gateways";
    target_id: string;
    status?: string | undefined;
    search?: string | undefined;
    per_page?: number | undefined;
    group?: string | undefined;
}>;
type WooReadInput = z.infer<typeof WooReadInputSchema>;
declare const WooReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    detected: z.ZodBoolean;
    items: z.ZodArray<z.ZodUnknown, "many">;
}, "strip", z.ZodTypeAny, {
    items: unknown[];
    scope: string;
    detected: boolean;
}, {
    items: unknown[];
    scope: string;
    detected: boolean;
}>;
type WooReadOutput = z.infer<typeof WooReadOutputSchema>;
declare const AcfReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["field_groups", "fields_in_group", "post_meta"]>;
    group_key: z.ZodOptional<z.ZodString>;
    post_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    scope: "field_groups" | "fields_in_group" | "post_meta";
    target_id: string;
    post_id?: number | undefined;
    group_key?: string | undefined;
}, {
    scope: "field_groups" | "fields_in_group" | "post_meta";
    target_id: string;
    post_id?: number | undefined;
    group_key?: string | undefined;
}>;
type AcfReadInput = z.infer<typeof AcfReadInputSchema>;
declare const AcfReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    detected: z.ZodBoolean;
    items: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    scope: string;
    detected: boolean;
    items?: unknown[] | undefined;
    meta?: Record<string, unknown> | undefined;
}, {
    scope: string;
    detected: boolean;
    items?: unknown[] | undefined;
    meta?: Record<string, unknown> | undefined;
}>;
type AcfReadOutput = z.infer<typeof AcfReadOutputSchema>;
declare const ElementorWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    widget_tree: z.ZodArray<z.ZodUnknown, "many">;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    widget_tree: unknown[];
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    widget_tree: unknown[];
    confirm?: boolean | undefined;
}>;
type ElementorWriteInput = z.infer<typeof ElementorWriteInputSchema>;
declare const ElementorWriteOutputSchema: z.ZodObject<{
    bytes_written: z.ZodNumber;
    backup_path: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    bytes_written: number;
    backup_path: string | null;
}, {
    bytes_written: number;
    backup_path: string | null;
}>;
type ElementorWriteOutput = z.infer<typeof ElementorWriteOutputSchema>;
declare const WooWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    op: z.ZodEnum<["update_product", "bulk_update_prices", "create_order", "update_order_status", "create_refund", "create_coupon", "create_variation"]>;
    product_id: z.ZodOptional<z.ZodNumber>;
    order_id: z.ZodOptional<z.ZodNumber>;
    order_status: z.ZodOptional<z.ZodString>;
    refund_amount: z.ZodOptional<z.ZodString>;
    refund_reason: z.ZodOptional<z.ZodString>;
    api_refund: z.ZodDefault<z.ZodBoolean>;
    fields: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, unknown>>;
    coupon: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, unknown>>;
    variation: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, unknown>>;
    price_updates: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        regular_price: z.ZodOptional<z.ZodString>;
        sale_price: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id: number;
        regular_price?: string | undefined;
        sale_price?: string | undefined;
    }, {
        id: number;
        regular_price?: string | undefined;
        sale_price?: string | undefined;
    }>, "many">>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    op: "update_product" | "bulk_update_prices" | "create_order" | "update_order_status" | "create_refund" | "create_coupon" | "create_variation";
    api_refund: boolean;
    product_id?: number | undefined;
    order_id?: number | undefined;
    order_status?: string | undefined;
    refund_amount?: string | undefined;
    refund_reason?: string | undefined;
    fields?: Record<string, unknown> | undefined;
    coupon?: Record<string, unknown> | undefined;
    variation?: Record<string, unknown> | undefined;
    price_updates?: {
        id: number;
        regular_price?: string | undefined;
        sale_price?: string | undefined;
    }[] | undefined;
}, {
    target_id: string;
    allow_destructive: true | "true";
    op: "update_product" | "bulk_update_prices" | "create_order" | "update_order_status" | "create_refund" | "create_coupon" | "create_variation";
    confirm?: boolean | undefined;
    product_id?: number | undefined;
    order_id?: number | undefined;
    order_status?: string | undefined;
    refund_amount?: string | undefined;
    refund_reason?: string | undefined;
    api_refund?: boolean | undefined;
    fields?: unknown;
    coupon?: unknown;
    variation?: unknown;
    price_updates?: {
        id: number;
        regular_price?: string | undefined;
        sale_price?: string | undefined;
    }[] | undefined;
}>;
type WooWriteInput = z.infer<typeof WooWriteInputSchema>;
declare const WooWriteOutputSchema: z.ZodObject<{
    op: z.ZodString;
    result: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    op: string;
    result?: unknown;
}, {
    op: string;
    result?: unknown;
}>;
type WooWriteOutput = z.infer<typeof WooWriteOutputSchema>;
declare const AcfWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    field_name: z.ZodString;
    value: z.ZodUnknown;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    field_name: string;
    value?: unknown;
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    field_name: string;
    value?: unknown;
    confirm?: boolean | undefined;
}>;
type AcfWriteInput = z.infer<typeof AcfWriteInputSchema>;
declare const AcfWriteOutputSchema: z.ZodObject<{
    source: z.ZodEnum<["rest_acf_pro", "wp_cli"]>;
    post_id: z.ZodNumber;
    field_name: z.ZodString;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    source: "wp_cli" | "rest_acf_pro";
    field_name: string;
}, {
    post_id: number;
    source: "wp_cli" | "rest_acf_pro";
    field_name: string;
}>;
type AcfWriteOutput = z.infer<typeof AcfWriteOutputSchema>;
declare const BricksReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    page_id: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: string;
    target_id: string;
    per_page: number;
    page_id?: number | undefined;
}, {
    target_id: string;
    type?: string | undefined;
    per_page?: number | undefined;
    page_id?: number | undefined;
}>;
type BricksReadInput = z.infer<typeof BricksReadInputSchema>;
declare const BricksReadOutputSchema: z.ZodObject<{
    mode: z.ZodEnum<["list", "page"]>;
    detected: z.ZodBoolean;
    pages: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    page: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}>;
type BricksReadOutput = z.infer<typeof BricksReadOutputSchema>;
declare const WpmlReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["languages", "string_translations", "post_translations"]>;
    domain: z.ZodOptional<z.ZodString>;
    post_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    scope: "languages" | "string_translations" | "post_translations";
    target_id: string;
    post_id?: number | undefined;
    domain?: string | undefined;
}, {
    scope: "languages" | "string_translations" | "post_translations";
    target_id: string;
    post_id?: number | undefined;
    domain?: string | undefined;
}>;
type WpmlReadInput = z.infer<typeof WpmlReadInputSchema>;
declare const WpmlReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    detected: z.ZodBoolean;
    data: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    scope: string;
    detected: boolean;
    data?: unknown;
}, {
    scope: string;
    detected: boolean;
    data?: unknown;
}>;
type WpmlReadOutput = z.infer<typeof WpmlReadOutputSchema>;
declare const YoastReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["post_meta", "settings"]>;
    post_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    scope: "post_meta" | "settings";
    target_id: string;
    post_id?: number | undefined;
}, {
    scope: "post_meta" | "settings";
    target_id: string;
    post_id?: number | undefined;
}>;
type YoastReadInput = z.infer<typeof YoastReadInputSchema>;
declare const YoastReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    detected: z.ZodBoolean;
    data: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    scope: string;
    detected: boolean;
    data?: unknown;
}, {
    scope: string;
    detected: boolean;
    data?: unknown;
}>;
type YoastReadOutput = z.infer<typeof YoastReadOutputSchema>;
declare const RankMathReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["post_meta", "settings"]>;
    post_id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    scope: "post_meta" | "settings";
    target_id: string;
    post_id?: number | undefined;
}, {
    scope: "post_meta" | "settings";
    target_id: string;
    post_id?: number | undefined;
}>;
type RankMathReadInput = z.infer<typeof RankMathReadInputSchema>;
declare const RankMathReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    detected: z.ZodBoolean;
    data: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    scope: string;
    detected: boolean;
    data?: unknown;
}, {
    scope: string;
    detected: boolean;
    data?: unknown;
}>;
type RankMathReadOutput = z.infer<typeof RankMathReadOutputSchema>;
declare const PairInputSchema: z.ZodObject<{
    siteurl: z.ZodEffects<z.ZodString, string, string>;
    pair_token: z.ZodString;
}, "strip", z.ZodTypeAny, {
    siteurl: string;
    pair_token: string;
}, {
    siteurl: string;
    pair_token: string;
}>;
type PairInput = z.infer<typeof PairInputSchema>;
declare const PairOutputSchema: z.ZodObject<{
    target_id: z.ZodString;
    siteurl: z.ZodString;
    username: z.ZodString;
    capabilities: z.ZodArray<z.ZodString, "many">;
    companion_version: z.ZodString;
    access_mode: z.ZodEnum<["full", "guarded"]>;
    prod_guard: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        armed: z.ZodBoolean;
        env_type: z.ZodNullable<z.ZodString>;
        reason: z.ZodEnum<["guarded", "full_access", "env_type", "host_pattern", "companion", "not_production", "unset", "probe_failed"]>;
    }, "strip", z.ZodTypeAny, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }, {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    }>>>;
    app_password_name: z.ZodString;
    credential_stored: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    siteurl: string;
    capabilities: string[];
    username: string;
    target_id: string;
    companion_version: string;
    access_mode: "full" | "guarded";
    app_password_name: string;
    credential_stored: boolean;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}, {
    siteurl: string;
    capabilities: string[];
    username: string;
    target_id: string;
    companion_version: string;
    access_mode: "full" | "guarded";
    app_password_name: string;
    credential_stored: boolean;
    prod_guard?: {
        reason: "companion" | "guarded" | "env_type" | "host_pattern" | "full_access" | "not_production" | "unset" | "probe_failed";
        env_type: string | null;
        armed: boolean;
    } | null | undefined;
}>;
type PairOutput = z.infer<typeof PairOutputSchema>;
declare const DiviReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    page_id: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: string;
    target_id: string;
    per_page: number;
    page_id?: number | undefined;
}, {
    target_id: string;
    type?: string | undefined;
    per_page?: number | undefined;
    page_id?: number | undefined;
}>;
type DiviReadInput = z.infer<typeof DiviReadInputSchema>;
declare const DiviReadOutputSchema: z.ZodObject<{
    mode: z.ZodEnum<["list", "page"]>;
    detected: z.ZodBoolean;
    pages: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    page: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}>;
type DiviReadOutput = z.infer<typeof DiviReadOutputSchema>;
declare const DiviWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    content: z.ZodString;
    ensure_builder_flag: z.ZodDefault<z.ZodBoolean>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    content: string;
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    ensure_builder_flag: boolean;
}, {
    content: string;
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    confirm?: boolean | undefined;
    ensure_builder_flag?: boolean | undefined;
}>;
type DiviWriteInput = z.infer<typeof DiviWriteInputSchema>;
declare const DiviWriteOutputSchema: z.ZodObject<{
    bytes_written: z.ZodNumber;
    backup_path: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    bytes_written: number;
    backup_path: string | null;
}, {
    bytes_written: number;
    backup_path: string | null;
}>;
type DiviWriteOutput = z.infer<typeof DiviWriteOutputSchema>;
declare const OxygenReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    page_id: z.ZodOptional<z.ZodNumber>;
    type: z.ZodDefault<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: string;
    target_id: string;
    per_page: number;
    page_id?: number | undefined;
}, {
    target_id: string;
    type?: string | undefined;
    per_page?: number | undefined;
    page_id?: number | undefined;
}>;
type OxygenReadInput = z.infer<typeof OxygenReadInputSchema>;
declare const OxygenReadOutputSchema: z.ZodObject<{
    mode: z.ZodEnum<["list", "page"]>;
    detected: z.ZodBoolean;
    pages: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    page: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}, {
    mode: "page" | "list";
    detected: boolean;
    page?: unknown;
    pages?: unknown[] | undefined;
}>;
type OxygenReadOutput = z.infer<typeof OxygenReadOutputSchema>;
declare const OxygenWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    shortcodes: z.ZodString;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    shortcodes: string;
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    shortcodes: string;
    confirm?: boolean | undefined;
}>;
type OxygenWriteInput = z.infer<typeof OxygenWriteInputSchema>;
declare const OxygenWriteOutputSchema: z.ZodObject<{
    bytes_written: z.ZodNumber;
    backup_path: z.ZodNullable<z.ZodString>;
    ct_builder_json_present: z.ZodOptional<z.ZodBoolean>;
    note: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    bytes_written: number;
    backup_path: string | null;
    note?: string | undefined;
    ct_builder_json_present?: boolean | undefined;
}, {
    bytes_written: number;
    backup_path: string | null;
    note?: string | undefined;
    ct_builder_json_present?: boolean | undefined;
}>;
type OxygenWriteOutput = z.infer<typeof OxygenWriteOutputSchema>;
declare const BricksWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    scope: z.ZodDefault<z.ZodEnum<["page", "header", "footer"]>>;
    elements: z.ZodArray<z.ZodUnknown, "many">;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    scope: "page" | "header" | "footer";
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    elements: unknown[];
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    elements: unknown[];
    scope?: "page" | "header" | "footer" | undefined;
    confirm?: boolean | undefined;
}>;
type BricksWriteInput = z.infer<typeof BricksWriteInputSchema>;
declare const BricksWriteOutputSchema: z.ZodObject<{
    scope: z.ZodEnum<["page", "header", "footer"]>;
    bytes_written: z.ZodNumber;
    backup_path: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    scope: "page" | "header" | "footer";
    bytes_written: number;
    backup_path: string | null;
}, {
    scope: "page" | "header" | "footer";
    bytes_written: number;
    backup_path: string | null;
}>;
type BricksWriteOutput = z.infer<typeof BricksWriteOutputSchema>;
declare const YoastWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    focus_keyword: z.ZodOptional<z.ZodString>;
    meta_description: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    canonical: z.ZodOptional<z.ZodString>;
    noindex: z.ZodOptional<z.ZodBoolean>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    title?: string | undefined;
    focus_keyword?: string | undefined;
    meta_description?: string | undefined;
    canonical?: string | undefined;
    noindex?: boolean | undefined;
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    title?: string | undefined;
    confirm?: boolean | undefined;
    focus_keyword?: string | undefined;
    meta_description?: string | undefined;
    canonical?: string | undefined;
    noindex?: boolean | undefined;
}>;
type YoastWriteInput = z.infer<typeof YoastWriteInputSchema>;
declare const YoastWriteOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    updated_fields: z.ZodArray<z.ZodString, "many">;
    source: z.ZodEnum<["wp_cli"]>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    source: "wp_cli";
    updated_fields: string[];
}, {
    post_id: number;
    source: "wp_cli";
    updated_fields: string[];
}>;
type YoastWriteOutput = z.infer<typeof YoastWriteOutputSchema>;
declare const RankMathWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    focus_keyword: z.ZodOptional<z.ZodString>;
    meta_description: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    canonical: z.ZodOptional<z.ZodString>;
    noindex: z.ZodOptional<z.ZodBoolean>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    title?: string | undefined;
    focus_keyword?: string | undefined;
    meta_description?: string | undefined;
    canonical?: string | undefined;
    noindex?: boolean | undefined;
}, {
    post_id: number;
    target_id: string;
    allow_destructive: true | "true";
    title?: string | undefined;
    confirm?: boolean | undefined;
    focus_keyword?: string | undefined;
    meta_description?: string | undefined;
    canonical?: string | undefined;
    noindex?: boolean | undefined;
}>;
type RankMathWriteInput = z.infer<typeof RankMathWriteInputSchema>;
declare const RankMathWriteOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    updated_fields: z.ZodArray<z.ZodString, "many">;
    source: z.ZodEnum<["wp_cli"]>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    source: "wp_cli";
    updated_fields: string[];
}, {
    post_id: number;
    source: "wp_cli";
    updated_fields: string[];
}>;
type RankMathWriteOutput = z.infer<typeof RankMathWriteOutputSchema>;
declare const WpmlWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    op: z.ZodEnum<["set_post_language", "link_translations", "duplicate_for_translation"]>;
    post_id: z.ZodOptional<z.ZodNumber>;
    original_post_id: z.ZodOptional<z.ZodNumber>;
    language_code: z.ZodOptional<z.ZodString>;
    target_language: z.ZodOptional<z.ZodString>;
    translations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    op: "set_post_language" | "link_translations" | "duplicate_for_translation";
    post_id?: number | undefined;
    original_post_id?: number | undefined;
    language_code?: string | undefined;
    target_language?: string | undefined;
    translations?: Record<string, number> | undefined;
}, {
    target_id: string;
    allow_destructive: true | "true";
    op: "set_post_language" | "link_translations" | "duplicate_for_translation";
    post_id?: number | undefined;
    confirm?: boolean | undefined;
    original_post_id?: number | undefined;
    language_code?: string | undefined;
    target_language?: string | undefined;
    translations?: Record<string, number> | undefined;
}>;
type WpmlWriteInput = z.infer<typeof WpmlWriteInputSchema>;
declare const WpmlWriteOutputSchema: z.ZodObject<{
    op: z.ZodString;
    source: z.ZodEnum<["wp_cli", "rest"]>;
    result: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    source: "rest" | "wp_cli";
    op: string;
    result?: unknown;
}, {
    source: "rest" | "wp_cli";
    op: string;
    result?: unknown;
}>;
type WpmlWriteOutput = z.infer<typeof WpmlWriteOutputSchema>;
declare const FormsReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["list_forms", "list_entries", "form_detail"]>;
    engine: z.ZodDefault<z.ZodEnum<["auto", "gravity", "cf7", "wpforms"]>>;
    form_id: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
    per_page: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    scope: "list_forms" | "list_entries" | "form_detail";
    target_id: string;
    per_page: number;
    engine: "auto" | "gravity" | "cf7" | "wpforms";
    form_id?: string | number | undefined;
}, {
    scope: "list_forms" | "list_entries" | "form_detail";
    target_id: string;
    per_page?: number | undefined;
    engine?: "auto" | "gravity" | "cf7" | "wpforms" | undefined;
    form_id?: string | number | undefined;
}>;
type FormsReadInput = z.infer<typeof FormsReadInputSchema>;
declare const FormsReadOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    engine_used: z.ZodEnum<["gravity", "cf7", "wpforms", "none"]>;
    detected: z.ZodBoolean;
    items: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    form: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    scope: string;
    detected: boolean;
    engine_used: "gravity" | "cf7" | "wpforms" | "none";
    items?: unknown[] | undefined;
    form?: unknown;
}, {
    scope: string;
    detected: boolean;
    engine_used: "gravity" | "cf7" | "wpforms" | "none";
    items?: unknown[] | undefined;
    form?: unknown;
}>;
type FormsReadOutput = z.infer<typeof FormsReadOutputSchema>;
declare const FormsWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    engine: z.ZodEnum<["gravity", "cf7", "wpforms"]>;
    op: z.ZodEnum<["delete_entry", "mark_spam", "unmark_spam"]>;
    entry_id: z.ZodNumber;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    op: "delete_entry" | "mark_spam" | "unmark_spam";
    engine: "gravity" | "cf7" | "wpforms";
    entry_id: number;
}, {
    target_id: string;
    allow_destructive: true | "true";
    op: "delete_entry" | "mark_spam" | "unmark_spam";
    engine: "gravity" | "cf7" | "wpforms";
    entry_id: number;
    confirm?: boolean | undefined;
}>;
type FormsWriteInput = z.infer<typeof FormsWriteInputSchema>;
declare const FormsWriteOutputSchema: z.ZodObject<{
    op: z.ZodString;
    entry_id: z.ZodNumber;
    source: z.ZodEnum<["rest", "wp_cli"]>;
}, "strip", z.ZodTypeAny, {
    source: "rest" | "wp_cli";
    op: string;
    entry_id: number;
}, {
    source: "rest" | "wp_cli";
    op: string;
    entry_id: number;
}>;
type FormsWriteOutput = z.infer<typeof FormsWriteOutputSchema>;
declare const CronToolInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    op: z.ZodEnum<["list", "run", "delete"]>;
    hook: z.ZodOptional<z.ZodString>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    confirm: boolean;
    op: "list" | "run" | "delete";
    hook?: string | undefined;
}, {
    target_id: string;
    op: "list" | "run" | "delete";
    confirm?: boolean | undefined;
    hook?: string | undefined;
}>;
type CronToolInput = z.infer<typeof CronToolInputSchema>;
declare const CronToolOutputSchema: z.ZodObject<{
    op: z.ZodString;
    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
        hook: z.ZodString;
        next_run_relative: z.ZodString;
        next_run_gmt: z.ZodString;
        recurrence: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        hook: string;
        next_run_relative: string;
        next_run_gmt: string;
        recurrence: string;
    }, {
        hook: string;
        next_run_relative: string;
        next_run_gmt: string;
        recurrence: string;
    }>, "many">>;
    ran: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    deleted_count: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    op: string;
    events?: {
        hook: string;
        next_run_relative: string;
        next_run_gmt: string;
        recurrence: string;
    }[] | undefined;
    ran?: string[] | undefined;
    deleted_count?: number | undefined;
}, {
    op: string;
    events?: {
        hook: string;
        next_run_relative: string;
        next_run_gmt: string;
        recurrence: string;
    }[] | undefined;
    ran?: string[] | undefined;
    deleted_count?: number | undefined;
}>;
type CronToolOutput = z.infer<typeof CronToolOutputSchema>;
declare const CacheToolInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    op: z.ZodEnum<["inspect", "detect", "flush_object", "flush_transients", "flush_page"]>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    confirm: boolean;
    op: "inspect" | "detect" | "flush_object" | "flush_transients" | "flush_page";
}, {
    target_id: string;
    op: "inspect" | "detect" | "flush_object" | "flush_transients" | "flush_page";
    confirm?: boolean | undefined;
}>;
type CacheToolInput = z.infer<typeof CacheToolInputSchema>;
declare const CacheToolOutputSchema: z.ZodObject<{
    op: z.ZodString;
    object_cache_active: z.ZodOptional<z.ZodBoolean>;
    transient_count: z.ZodOptional<z.ZodNumber>;
    expired_transient_count: z.ZodOptional<z.ZodNumber>;
    flushed: z.ZodOptional<z.ZodBoolean>;
    layers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
    caveat: z.ZodOptional<z.ZodString>;
    multisite: z.ZodOptional<z.ZodBoolean>;
    purged: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    manual_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    failed: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
}, "strip", z.ZodTypeAny, {
    op: string;
    failed?: Record<string, unknown>[] | undefined;
    object_cache_active?: boolean | undefined;
    transient_count?: number | undefined;
    expired_transient_count?: number | undefined;
    flushed?: boolean | undefined;
    layers?: Record<string, unknown>[] | undefined;
    caveat?: string | undefined;
    multisite?: boolean | undefined;
    purged?: string[] | undefined;
    manual_required?: string[] | undefined;
}, {
    op: string;
    failed?: Record<string, unknown>[] | undefined;
    object_cache_active?: boolean | undefined;
    transient_count?: number | undefined;
    expired_transient_count?: number | undefined;
    flushed?: boolean | undefined;
    layers?: Record<string, unknown>[] | undefined;
    caveat?: string | undefined;
    multisite?: boolean | undefined;
    purged?: string[] | undefined;
    manual_required?: string[] | undefined;
}>;
type CacheToolOutput = z.infer<typeof CacheToolOutputSchema>;
declare const MailTestInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    to: z.ZodString;
    subject: z.ZodDefault<z.ZodString>;
    body: z.ZodDefault<z.ZodString>;
    confirm: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    body: string;
    to: string;
    target_id: string;
    confirm: true;
    subject: string;
}, {
    to: string;
    target_id: string;
    confirm: true | "true";
    body?: string | undefined;
    subject?: string | undefined;
}>;
type MailTestInput = z.infer<typeof MailTestInputSchema>;
declare const MailTestOutputSchema: z.ZodObject<{
    to: z.ZodString;
    delivered: z.ZodBoolean;
    source: z.ZodEnum<["companion_php", "wp_cli_eval"]>;
    detail: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    to: string;
    source: "companion_php" | "wp_cli_eval";
    delivered: boolean;
    detail?: string | undefined;
}, {
    to: string;
    source: "companion_php" | "wp_cli_eval";
    delivered: boolean;
    detail?: string | undefined;
}>;
type MailTestOutput = z.infer<typeof MailTestOutputSchema>;
declare const CloneInputSchema: z.ZodObject<{
    source_target_id: z.ZodString;
    dest_target_id: z.ZodString;
    scope: z.ZodDefault<z.ZodArray<z.ZodEnum<["db", "wp_content", "plugin_versions"]>, "many">>;
    rewrite_urls: z.ZodDefault<z.ZodBoolean>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    scope: ("db" | "plugin_versions" | "wp_content")[];
    allow_destructive: true;
    confirm: boolean;
    source_target_id: string;
    dest_target_id: string;
    rewrite_urls: boolean;
}, {
    allow_destructive: true | "true";
    source_target_id: string;
    dest_target_id: string;
    scope?: ("db" | "plugin_versions" | "wp_content")[] | undefined;
    confirm?: boolean | undefined;
    rewrite_urls?: boolean | undefined;
}>;
type CloneInput = z.infer<typeof CloneInputSchema>;
declare const CloneOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    steps: z.ZodArray<z.ZodObject<{
        step: z.ZodString;
        ok: z.ZodBoolean;
        detail: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }, {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }>, "many">;
    report_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    report_path: string;
    steps: {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }[];
}, {
    run_id: string;
    report_path: string;
    steps: {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }[];
}>;
type CloneOutput = z.infer<typeof CloneOutputSchema>;
declare const BackupCreateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodDefault<z.ZodArray<z.ZodEnum<["db", "wp_content"]>, "many">>;
    label: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    scope: ("db" | "wp_content")[];
    target_id: string;
    label?: string | undefined;
}, {
    target_id: string;
    scope?: ("db" | "wp_content")[] | undefined;
    label?: string | undefined;
}>;
type BackupCreateInput = z.infer<typeof BackupCreateInputSchema>;
declare const BackupCreateOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    artifact_dir: z.ZodString;
    artifacts: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<["db", "wp_content"]>;
        path: z.ZodString;
        bytes: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        path: string;
        kind: "db" | "wp_content";
        bytes: number;
    }, {
        path: string;
        kind: "db" | "wp_content";
        bytes: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    artifact_dir: string;
    artifacts: {
        path: string;
        kind: "db" | "wp_content";
        bytes: number;
    }[];
}, {
    run_id: string;
    artifact_dir: string;
    artifacts: {
        path: string;
        kind: "db" | "wp_content";
        bytes: number;
    }[];
}>;
type BackupCreateOutput = z.infer<typeof BackupCreateOutputSchema>;
declare const BackupRestoreInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    artifact_dir: z.ZodString;
    scope: z.ZodDefault<z.ZodArray<z.ZodEnum<["db", "wp_content"]>, "many">>;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    scope: ("db" | "wp_content")[];
    target_id: string;
    allow_destructive: true;
    confirm: boolean;
    artifact_dir: string;
}, {
    target_id: string;
    allow_destructive: true | "true";
    artifact_dir: string;
    scope?: ("db" | "wp_content")[] | undefined;
    confirm?: boolean | undefined;
}>;
type BackupRestoreInput = z.infer<typeof BackupRestoreInputSchema>;
declare const BackupRestoreOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    restored: z.ZodArray<z.ZodObject<{
        kind: z.ZodEnum<["db", "wp_content"]>;
        ok: z.ZodBoolean;
        detail: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        kind: "db" | "wp_content";
        ok: boolean;
        detail?: string | undefined;
    }, {
        kind: "db" | "wp_content";
        ok: boolean;
        detail?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    restored: {
        kind: "db" | "wp_content";
        ok: boolean;
        detail?: string | undefined;
    }[];
}, {
    run_id: string;
    restored: {
        kind: "db" | "wp_content";
        ok: boolean;
        detail?: string | undefined;
    }[];
}>;
type BackupRestoreOutput = z.infer<typeof BackupRestoreOutputSchema>;
declare const UserSessionListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    per_page: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    per_page: number;
}, {
    target_id: string;
    per_page?: number | undefined;
}>;
type UserSessionListInput = z.infer<typeof UserSessionListInputSchema>;
declare const UserSessionListOutputSchema: z.ZodObject<{
    total_users_with_sessions: z.ZodNumber;
    sessions: z.ZodArray<z.ZodObject<{
        user_id: z.ZodNumber;
        user_login: z.ZodString;
        token_count: z.ZodNumber;
        tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
            login_ip: z.ZodOptional<z.ZodString>;
            ua: z.ZodOptional<z.ZodString>;
            login_time_gmt: z.ZodOptional<z.ZodString>;
            expiration_gmt: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }, {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        user_id: number;
        user_login: string;
        token_count: number;
        tokens?: {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }[] | undefined;
    }, {
        user_id: number;
        user_login: string;
        token_count: number;
        tokens?: {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }[] | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    total_users_with_sessions: number;
    sessions: {
        user_id: number;
        user_login: string;
        token_count: number;
        tokens?: {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }[] | undefined;
    }[];
}, {
    total_users_with_sessions: number;
    sessions: {
        user_id: number;
        user_login: string;
        token_count: number;
        tokens?: {
            login_ip?: string | undefined;
            ua?: string | undefined;
            login_time_gmt?: string | undefined;
            expiration_gmt?: string | undefined;
        }[] | undefined;
    }[];
}>;
type UserSessionListOutput = z.infer<typeof UserSessionListOutputSchema>;
declare const RestDumpInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    filter_namespace: z.ZodOptional<z.ZodString>;
    full: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    full: boolean;
    target_id: string;
    filter_namespace?: string | undefined;
}, {
    target_id: string;
    full?: boolean | undefined;
    filter_namespace?: string | undefined;
}>;
type RestDumpInput = z.infer<typeof RestDumpInputSchema>;
declare const RestDumpOutputSchema: z.ZodObject<{
    namespaces: z.ZodArray<z.ZodString, "many">;
    route_count: z.ZodNumber;
    routes_by_namespace: z.ZodRecord<z.ZodString, z.ZodNumber>;
    routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        namespace: z.ZodString;
        methods: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        path: string;
        namespace: string;
        methods: string[];
    }, {
        path: string;
        namespace: string;
        methods: string[];
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    namespaces: string[];
    route_count: number;
    routes_by_namespace: Record<string, number>;
    routes?: {
        path: string;
        namespace: string;
        methods: string[];
    }[] | undefined;
}, {
    namespaces: string[];
    route_count: number;
    routes_by_namespace: Record<string, number>;
    routes?: {
        path: string;
        namespace: string;
        methods: string[];
    }[] | undefined;
}>;
type RestDumpOutput = z.infer<typeof RestDumpOutputSchema>;
declare const ScaffoldPatternInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    host: z.ZodEnum<["theme", "plugin"]>;
    host_slug: z.ZodString;
    pattern_slug: z.ZodString;
    title: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    categories: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    content: z.ZodString;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
}, "strip", z.ZodTypeAny, {
    content: string;
    title: string;
    host: "plugin" | "theme";
    target_id: string;
    allow_destructive: true;
    categories: string[];
    host_slug: string;
    pattern_slug: string;
    description?: string | undefined;
}, {
    content: string;
    title: string;
    host: "plugin" | "theme";
    target_id: string;
    allow_destructive: true | "true";
    host_slug: string;
    pattern_slug: string;
    description?: string | undefined;
    categories?: string[] | undefined;
}>;
type ScaffoldPatternInput = z.infer<typeof ScaffoldPatternInputSchema>;
declare const ScaffoldPatternOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    file_written: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    file_written: string;
}, {
    run_id: string;
    file_written: string;
}>;
type ScaffoldPatternOutput = z.infer<typeof ScaffoldPatternOutputSchema>;
declare const DiagnoseInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scopes: z.ZodDefault<z.ZodArray<z.ZodEnum<["plugin_conflict_probe", "slow_queries", "large_options", "broken_images", "php_errors", "page_cache"]>, "many">>;
    report_format: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    report_format: "json" | "markdown";
    scopes: ("plugin_conflict_probe" | "slow_queries" | "large_options" | "broken_images" | "php_errors" | "page_cache")[];
}, {
    target_id: string;
    report_format?: "json" | "markdown" | undefined;
    scopes?: ("plugin_conflict_probe" | "slow_queries" | "large_options" | "broken_images" | "php_errors" | "page_cache")[] | undefined;
}>;
type DiagnoseInput = z.infer<typeof DiagnoseInputSchema>;
declare const DiagnoseOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    findings: z.ZodArray<z.ZodObject<{
        scope: z.ZodString;
        severity: z.ZodEnum<["info", "warn", "critical"]>;
        message: z.ZodString;
        detail: z.ZodOptional<z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        scope: string;
        severity: "warn" | "info" | "critical";
        detail?: unknown;
    }, {
        message: string;
        scope: string;
        severity: "warn" | "info" | "critical";
        detail?: unknown;
    }>, "many">;
    report_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    run_id: string;
    report_path: string;
    findings: {
        message: string;
        scope: string;
        severity: "warn" | "info" | "critical";
        detail?: unknown;
    }[];
}, {
    run_id: string;
    report_path: string;
    findings: {
        message: string;
        scope: string;
        severity: "warn" | "info" | "critical";
        detail?: unknown;
    }[];
}>;
type DiagnoseOutput = z.infer<typeof DiagnoseOutputSchema>;
declare const WpFileReadInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    path: z.ZodString;
    offset: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodOptional<z.ZodNumber>;
    grep: z.ZodOptional<z.ZodString>;
    context: z.ZodDefault<z.ZodNumber>;
    ignore_case: z.ZodDefault<z.ZodBoolean>;
    max_bytes: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    path: string;
    target_id: string;
    context: number;
    ignore_case: boolean;
    limit?: number | undefined;
    max_bytes?: number | undefined;
    offset?: number | undefined;
    grep?: string | undefined;
}, {
    path: string;
    target_id: string;
    limit?: number | undefined;
    max_bytes?: number | undefined;
    context?: number | undefined;
    offset?: number | undefined;
    grep?: string | undefined;
    ignore_case?: boolean | undefined;
}>;
type WpFileReadInput = z.infer<typeof WpFileReadInputSchema>;
declare const WpFileReadOutputSchema: z.ZodObject<{
    path: z.ZodString;
    content: z.ZodString;
    bytes: z.ZodNumber;
    returned_bytes: z.ZodOptional<z.ZodNumber>;
    truncated: z.ZodOptional<z.ZodBoolean>;
    matched_lines: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    path: string;
    content: string;
    bytes: number;
    truncated?: boolean | undefined;
    returned_bytes?: number | undefined;
    matched_lines?: number | undefined;
}, {
    path: string;
    content: string;
    bytes: number;
    truncated?: boolean | undefined;
    returned_bytes?: number | undefined;
    matched_lines?: number | undefined;
}>;
type WpFileReadOutput = z.infer<typeof WpFileReadOutputSchema>;
declare const WpFileWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    path: z.ZodString;
    content: z.ZodString;
    mode: z.ZodDefault<z.ZodEnum<["overwrite", "append"]>>;
    backup: z.ZodDefault<z.ZodBoolean>;
    confirm_unsafe_path: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    path: string;
    content: string;
    mode: "overwrite" | "append";
    backup: boolean;
    target_id: string;
    confirm_unsafe_path: boolean;
}, {
    path: string;
    content: string;
    target_id: string;
    mode?: "overwrite" | "append" | undefined;
    backup?: boolean | undefined;
    confirm_unsafe_path?: boolean | undefined;
}>;
type WpFileWriteInput = z.infer<typeof WpFileWriteInputSchema>;
declare const WpFileWriteOutputSchema: z.ZodObject<{
    path: z.ZodString;
    bytes_written: z.ZodNumber;
    backup_path: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    path: string;
    bytes_written: number;
    backup_path: string | null;
}, {
    path: string;
    bytes_written: number;
    backup_path: string | null;
}>;
type WpFileWriteOutput = z.infer<typeof WpFileWriteOutputSchema>;
declare const TargetAliasInputSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
    action: z.ZodLiteral<"set">;
    alias: z.ZodString;
    siteurl: z.ZodEffects<z.ZodString, string, string>;
    credential_ref: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    siteurl: string;
    action: "set";
    alias: string;
    credential_ref?: string | undefined;
}, {
    siteurl: string;
    action: "set";
    alias: string;
    credential_ref?: string | undefined;
}>, z.ZodObject<{
    action: z.ZodLiteral<"list">;
}, "strip", z.ZodTypeAny, {
    action: "list";
}, {
    action: "list";
}>, z.ZodObject<{
    action: z.ZodLiteral<"rm">;
    alias: z.ZodString;
}, "strip", z.ZodTypeAny, {
    action: "rm";
    alias: string;
}, {
    action: "rm";
    alias: string;
}>, z.ZodObject<{
    action: z.ZodLiteral<"resolve">;
    alias: z.ZodString;
}, "strip", z.ZodTypeAny, {
    action: "resolve";
    alias: string;
}, {
    action: "resolve";
    alias: string;
}>]>;
type TargetAliasInput = z.infer<typeof TargetAliasInputSchema>;
declare const TargetAliasOutputSchema: z.ZodObject<{
    action: z.ZodEnum<["set", "list", "rm", "resolve"]>;
    alias: z.ZodOptional<z.ZodString>;
    siteurl: z.ZodOptional<z.ZodString>;
    credential_ref: z.ZodOptional<z.ZodString>;
    target_id: z.ZodOptional<z.ZodString>;
    removed: z.ZodOptional<z.ZodBoolean>;
    aliases: z.ZodOptional<z.ZodArray<z.ZodObject<{
        alias: z.ZodString;
        siteurl: z.ZodString;
        credential_ref: z.ZodString;
        added_at: z.ZodString;
        last_used_at: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        siteurl: string;
        credential_ref: string;
        alias: string;
        added_at: string;
        last_used_at?: string | undefined;
    }, {
        siteurl: string;
        credential_ref: string;
        alias: string;
        added_at: string;
        last_used_at?: string | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    action: "set" | "list" | "rm" | "resolve";
    siteurl?: string | undefined;
    target_id?: string | undefined;
    credential_ref?: string | undefined;
    alias?: string | undefined;
    removed?: boolean | undefined;
    aliases?: {
        siteurl: string;
        credential_ref: string;
        alias: string;
        added_at: string;
        last_used_at?: string | undefined;
    }[] | undefined;
}, {
    action: "set" | "list" | "rm" | "resolve";
    siteurl?: string | undefined;
    target_id?: string | undefined;
    credential_ref?: string | undefined;
    alias?: string | undefined;
    removed?: boolean | undefined;
    aliases?: {
        siteurl: string;
        credential_ref: string;
        alias: string;
        added_at: string;
        last_used_at?: string | undefined;
    }[] | undefined;
}>;
type TargetAliasOutput = z.infer<typeof TargetAliasOutputSchema>;
declare const WpFileWriteBatchInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    writes: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        content: z.ZodString;
        mode: z.ZodDefault<z.ZodEnum<["overwrite", "append"]>>;
        confirm_unsafe_path: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        path: string;
        content: string;
        mode: "overwrite" | "append";
        confirm_unsafe_path: boolean;
    }, {
        path: string;
        content: string;
        mode?: "overwrite" | "append" | undefined;
        confirm_unsafe_path?: boolean | undefined;
    }>, "many">;
    skip_php_lint: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    writes: {
        path: string;
        content: string;
        mode: "overwrite" | "append";
        confirm_unsafe_path: boolean;
    }[];
    skip_php_lint: boolean;
}, {
    target_id: string;
    writes: {
        path: string;
        content: string;
        mode?: "overwrite" | "append" | undefined;
        confirm_unsafe_path?: boolean | undefined;
    }[];
    skip_php_lint?: boolean | undefined;
}>;
type WpFileWriteBatchInput = z.infer<typeof WpFileWriteBatchInputSchema>;
declare const WpFileWriteBatchOutputSchema: z.ZodObject<{
    batch_id: z.ZodString;
    written: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        absolute_path: z.ZodString;
        bytes_written: z.ZodNumber;
        backup_path: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        path: string;
        absolute_path: string;
        bytes_written: number;
        backup_path: string | null;
    }, {
        path: string;
        absolute_path: string;
        bytes_written: number;
        backup_path: string | null;
    }>, "many">;
    preflight: z.ZodObject<{
        php_lint_ran: z.ZodBoolean;
        require_chain_ran: z.ZodBoolean;
        entries_scanned: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        php_lint_ran: boolean;
        require_chain_ran: boolean;
        entries_scanned: number;
    }, {
        php_lint_ran: boolean;
        require_chain_ran: boolean;
        entries_scanned: number;
    }>;
}, "strip", z.ZodTypeAny, {
    written: {
        path: string;
        absolute_path: string;
        bytes_written: number;
        backup_path: string | null;
    }[];
    preflight: {
        php_lint_ran: boolean;
        require_chain_ran: boolean;
        entries_scanned: number;
    };
    batch_id: string;
}, {
    written: {
        path: string;
        absolute_path: string;
        bytes_written: number;
        backup_path: string | null;
    }[];
    preflight: {
        php_lint_ran: boolean;
        require_chain_ran: boolean;
        entries_scanned: number;
    };
    batch_id: string;
}>;
type WpFileWriteBatchOutput = z.infer<typeof WpFileWriteBatchOutputSchema>;
declare const WpDirEnsureInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
    target_id: string;
}, {
    path: string;
    target_id: string;
}>;
type WpDirEnsureInput = z.infer<typeof WpDirEnsureInputSchema>;
declare const WpDirEnsureOutputSchema: z.ZodObject<{
    path: z.ZodString;
    absolute_path: z.ZodString;
    created: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    path: string;
    absolute_path: string;
    created: boolean;
}, {
    path: string;
    absolute_path: string;
    created: boolean;
}>;
type WpDirEnsureOutput = z.infer<typeof WpDirEnsureOutputSchema>;
declare const WpFileCopyInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    from: z.ZodString;
    to: z.ZodString;
    overwrite: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    overwrite: boolean;
    from: string;
    to: string;
    target_id: string;
}, {
    from: string;
    to: string;
    target_id: string;
    overwrite?: boolean | undefined;
}>;
type WpFileCopyInput = z.infer<typeof WpFileCopyInputSchema>;
declare const WpFileCopyOutputSchema: z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
    bytes: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    bytes: number;
    from: string;
    to: string;
}, {
    bytes: number;
    from: string;
    to: string;
}>;
type WpFileCopyOutput = z.infer<typeof WpFileCopyOutputSchema>;
declare const WpFileListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    path: z.ZodString;
    depth: z.ZodDefault<z.ZodNumber>;
    include_hidden: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    path: string;
    depth: number;
    include_hidden: boolean;
    target_id: string;
}, {
    path: string;
    target_id: string;
    depth?: number | undefined;
    include_hidden?: boolean | undefined;
}>;
type WpFileListInput = z.infer<typeof WpFileListInputSchema>;
declare const WpFileListOutputSchema: z.ZodObject<{
    root: z.ZodString;
    truncated: z.ZodBoolean;
    entries: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        type: z.ZodEnum<["file", "dir"]>;
        bytes: z.ZodNumber;
        mtime: z.ZodNumber;
        depth: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        path: string;
        type: "file" | "dir";
        bytes: number;
        depth: number;
        mtime: number;
    }, {
        path: string;
        type: "file" | "dir";
        bytes: number;
        depth: number;
        mtime: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    entries: {
        path: string;
        type: "file" | "dir";
        bytes: number;
        depth: number;
        mtime: number;
    }[];
    root: string;
    truncated: boolean;
}, {
    entries: {
        path: string;
        type: "file" | "dir";
        bytes: number;
        depth: number;
        mtime: number;
    }[];
    root: string;
    truncated: boolean;
}>;
type WpFileListOutput = z.infer<typeof WpFileListOutputSchema>;
declare const WpElementorWidgetSchemaInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    widget: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    widget?: string | undefined;
}, {
    target_id: string;
    widget?: string | undefined;
}>;
type WpElementorWidgetSchemaInput = z.infer<typeof WpElementorWidgetSchemaInputSchema>;
declare const WpElementorWidgetSchemaOutputSchema: z.ZodObject<{
    ok: z.ZodBoolean;
    elementor_version: z.ZodString;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    ok: z.ZodBoolean;
    elementor_version: z.ZodString;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    ok: z.ZodBoolean;
    elementor_version: z.ZodString;
}, z.ZodTypeAny, "passthrough">>;
type WpElementorWidgetSchemaOutput = z.infer<typeof WpElementorWidgetSchemaOutputSchema>;
declare const WpElementorTemplateExportInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
}, {
    post_id: number;
    target_id: string;
}>;
type WpElementorTemplateExportInput = z.infer<typeof WpElementorTemplateExportInputSchema>;
declare const WpElementorTemplateExportOutputSchema: z.ZodObject<{
    ok: z.ZodBoolean;
    post_id: z.ZodNumber;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    ok: z.ZodBoolean;
    post_id: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    ok: z.ZodBoolean;
    post_id: z.ZodNumber;
}, z.ZodTypeAny, "passthrough">>;
type WpElementorTemplateExportOutput = z.infer<typeof WpElementorTemplateExportOutputSchema>;
declare const WpElementorPublishInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    warm_cache: z.ZodDefault<z.ZodBoolean>;
    bump_theme_assets: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    warm_cache: boolean;
    bump_theme_assets: boolean;
}, {
    post_id: number;
    target_id: string;
    warm_cache?: boolean | undefined;
    bump_theme_assets?: boolean | undefined;
}>;
type WpElementorPublishInput = z.infer<typeof WpElementorPublishInputSchema>;
declare const WpElementorPublishOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    permalink: z.ZodString;
    elementor_flush: z.ZodObject<{
        ok: z.ZodBoolean;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        ok: boolean;
    }, {
        message: string;
        ok: boolean;
    }>;
    object_cache_flush: z.ZodObject<{
        ok: z.ZodBoolean;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        ok: boolean;
    }, {
        message: string;
        ok: boolean;
    }>;
    theme_assets_bumped: z.ZodOptional<z.ZodObject<{
        ok: z.ZodBoolean;
        files_touched: z.ZodNumber;
        theme_dir: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        ok: boolean;
        files_touched: number;
        theme_dir: string;
    }, {
        ok: boolean;
        files_touched: number;
        theme_dir: string;
    }>>;
    warm_fetch: z.ZodOptional<z.ZodObject<{
        ok: z.ZodBoolean;
        status: z.ZodNumber;
        bytes: z.ZodNumber;
        duration_ms: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        status: number;
        ok: boolean;
        bytes: number;
        duration_ms: number;
    }, {
        status: number;
        ok: boolean;
        bytes: number;
        duration_ms: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    permalink: string;
    elementor_flush: {
        message: string;
        ok: boolean;
    };
    object_cache_flush: {
        message: string;
        ok: boolean;
    };
    theme_assets_bumped?: {
        ok: boolean;
        files_touched: number;
        theme_dir: string;
    } | undefined;
    warm_fetch?: {
        status: number;
        ok: boolean;
        bytes: number;
        duration_ms: number;
    } | undefined;
}, {
    post_id: number;
    permalink: string;
    elementor_flush: {
        message: string;
        ok: boolean;
    };
    object_cache_flush: {
        message: string;
        ok: boolean;
    };
    theme_assets_bumped?: {
        ok: boolean;
        files_touched: number;
        theme_dir: string;
    } | undefined;
    warm_fetch?: {
        status: number;
        ok: boolean;
        bytes: number;
        duration_ms: number;
    } | undefined;
}>;
type WpElementorPublishOutput = z.infer<typeof WpElementorPublishOutputSchema>;
declare const WpElementorValidateDataInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    sections: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
    strict: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    strict: boolean;
    sections: Record<string, unknown>[];
    target_id: string;
}, {
    sections: Record<string, unknown>[];
    target_id: string;
    strict?: boolean | undefined;
}>;
type WpElementorValidateDataInput = z.infer<typeof WpElementorValidateDataInputSchema>;
declare const WpElementorValidateDataOutputSchema: z.ZodObject<{
    ok: z.ZodBoolean;
    widgets_scanned: z.ZodNumber;
    widget_types_seen: z.ZodArray<z.ZodString, "many">;
    errors: z.ZodArray<z.ZodObject<{
        widget_id: z.ZodString;
        widget_type: z.ZodString;
        setting_key: z.ZodString;
        reason: z.ZodString;
        expected_type: z.ZodOptional<z.ZodString>;
        actual_type: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
        expected_type?: string | undefined;
        actual_type?: string | undefined;
    }, {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
        expected_type?: string | undefined;
        actual_type?: string | undefined;
    }>, "many">;
    warnings: z.ZodArray<z.ZodObject<{
        widget_id: z.ZodString;
        widget_type: z.ZodString;
        setting_key: z.ZodString;
        reason: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
    }, {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    ok: boolean;
    warnings: {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
    }[];
    widgets_scanned: number;
    widget_types_seen: string[];
    errors: {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
        expected_type?: string | undefined;
        actual_type?: string | undefined;
    }[];
}, {
    ok: boolean;
    warnings: {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
    }[];
    widgets_scanned: number;
    widget_types_seen: string[];
    errors: {
        reason: string;
        widget_id: string;
        widget_type: string;
        setting_key: string;
        expected_type?: string | undefined;
        actual_type?: string | undefined;
    }[];
}>;
type WpElementorValidateDataOutput = z.infer<typeof WpElementorValidateDataOutputSchema>;
declare const WpElementorWidgetAttributeInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    widget_id: z.ZodString;
    attrs: z.ZodRecord<z.ZodString, z.ZodString>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    widget_id: string;
    target_id: string;
    attrs: Record<string, string>;
}, {
    post_id: number;
    widget_id: string;
    target_id: string;
    attrs: Record<string, string>;
}>;
type WpElementorWidgetAttributeInput = z.infer<typeof WpElementorWidgetAttributeInputSchema>;
declare const WpElementorWidgetAttributeOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    widget_id: z.ZodString;
    attrs_now: z.ZodRecord<z.ZodString, z.ZodString>;
    widgets_total: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    widget_id: string;
    attrs_now: Record<string, string>;
    widgets_total: number;
}, {
    post_id: number;
    widget_id: string;
    attrs_now: Record<string, string>;
    widgets_total: number;
}>;
type WpElementorWidgetAttributeOutput = z.infer<typeof WpElementorWidgetAttributeOutputSchema>;
declare const WpElementorTemplateApplyInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    target_post_id: z.ZodNumber;
    sections: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
    replace_strings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    overwrite: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    overwrite: boolean;
    target_post_id: number;
    sections: Record<string, unknown>[];
    target_id: string;
    replace_strings?: Record<string, string> | undefined;
}, {
    target_post_id: number;
    sections: Record<string, unknown>[];
    target_id: string;
    overwrite?: boolean | undefined;
    replace_strings?: Record<string, string> | undefined;
}>;
type WpElementorTemplateApplyInput = z.infer<typeof WpElementorTemplateApplyInputSchema>;
declare const WpElementorTemplateApplyOutputSchema: z.ZodObject<{
    target_post_id: z.ZodNumber;
    section_count: z.ZodNumber;
    replacements_applied: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    target_post_id: number;
    section_count: number;
    replacements_applied: number;
}, {
    target_post_id: number;
    section_count: number;
    replacements_applied: number;
}>;
type WpElementorTemplateApplyOutput = z.infer<typeof WpElementorTemplateApplyOutputSchema>;
declare const WpJobCreateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    args: z.ZodArray<z.ZodString, "many">;
    timeout_seconds: z.ZodDefault<z.ZodNumber>;
    allow_destructive: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    args: string[];
    target_id: string;
    allow_destructive: boolean;
    timeout_seconds: number;
}, {
    args: string[];
    target_id: string;
    allow_destructive?: boolean | undefined;
    timeout_seconds?: number | undefined;
}>;
type WpJobCreateInput = z.infer<typeof WpJobCreateInputSchema>;
declare const WpJobCreateOutputSchema: z.ZodObject<{
    job_id: z.ZodString;
    pid: z.ZodNumber;
    log: z.ZodObject<{
        stdout: z.ZodString;
        stderr: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        stdout: string;
        stderr: string;
    }, {
        stdout: string;
        stderr: string;
    }>;
    started_at: z.ZodNumber;
    ttl_seconds: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    pid: number;
    log: {
        stdout: string;
        stderr: string;
    };
    job_id: string;
    started_at: number;
    ttl_seconds: number;
}, {
    pid: number;
    log: {
        stdout: string;
        stderr: string;
    };
    job_id: string;
    started_at: number;
    ttl_seconds: number;
}>;
type WpJobCreateOutput = z.infer<typeof WpJobCreateOutputSchema>;
declare const WpJobStatusInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    job_id: z.ZodString;
    tail: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    job_id: string;
    tail: number;
    target_id: string;
}, {
    job_id: string;
    target_id: string;
    tail?: number | undefined;
}>;
type WpJobStatusInput = z.infer<typeof WpJobStatusInputSchema>;
declare const WpJobStatusOutputSchema: z.ZodObject<{
    job_id: z.ZodString;
    pid: z.ZodNumber;
    args: z.ZodArray<z.ZodString, "many">;
    started_at: z.ZodNumber;
    state: z.ZodEnum<["running", "completed", "failed", "unknown"]>;
    elapsed_seconds: z.ZodNumber;
    stdout_tail: z.ZodString;
    stderr_tail: z.ZodString;
    log: z.ZodObject<{
        stdout: z.ZodString;
        stderr: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        stdout: string;
        stderr: string;
    }, {
        stdout: string;
        stderr: string;
    }>;
    exit_code: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    args: string[];
    pid: number;
    log: {
        stdout: string;
        stderr: string;
    };
    job_id: string;
    started_at: number;
    state: "unknown" | "running" | "completed" | "failed";
    elapsed_seconds: number;
    stdout_tail: string;
    stderr_tail: string;
    exit_code?: number | undefined;
}, {
    args: string[];
    pid: number;
    log: {
        stdout: string;
        stderr: string;
    };
    job_id: string;
    started_at: number;
    state: "unknown" | "running" | "completed" | "failed";
    elapsed_seconds: number;
    stdout_tail: string;
    stderr_tail: string;
    exit_code?: number | undefined;
}>;
type WpJobStatusOutput = z.infer<typeof WpJobStatusOutputSchema>;
declare const WpMediaOptimizeInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    mode: z.ZodDefault<z.ZodEnum<["immediate", "enqueue"]>>;
    apply: z.ZodDefault<z.ZodBoolean>;
    min_bytes: z.ZodDefault<z.ZodNumber>;
    max_dimension: z.ZodDefault<z.ZodNumber>;
    quality: z.ZodDefault<z.ZodNumber>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    mode: "immediate" | "enqueue";
    target_id: string;
    apply: boolean;
    min_bytes: number;
    max_dimension: number;
    quality: number;
}, {
    target_id: string;
    limit?: number | undefined;
    mode?: "immediate" | "enqueue" | undefined;
    apply?: boolean | undefined;
    min_bytes?: number | undefined;
    max_dimension?: number | undefined;
    quality?: number | undefined;
}>;
type WpMediaOptimizeInput = z.infer<typeof WpMediaOptimizeInputSchema>;
declare const WpMediaOptimizeOutputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
type WpMediaOptimizeOutput = z.infer<typeof WpMediaOptimizeOutputSchema>;
declare const WpMediaUploadInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
    target_id: z.ZodString;
    source: z.ZodEnum<["base64", "url", "local_path"]>;
    data: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
    filename: z.ZodOptional<z.ZodString>;
    alt: z.ZodOptional<z.ZodString>;
    title: z.ZodOptional<z.ZodString>;
    caption: z.ZodOptional<z.ZodString>;
    attach_to_post: z.ZodOptional<z.ZodNumber>;
    attach_to_post_type: z.ZodDefault<z.ZodString>;
    set_featured: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    attach_to_post_type: string;
    set_featured: boolean;
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
}, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
    attach_to_post_type?: string | undefined;
    set_featured?: boolean | undefined;
}>, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    attach_to_post_type: string;
    set_featured: boolean;
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
}, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
    attach_to_post_type?: string | undefined;
    set_featured?: boolean | undefined;
}>, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    attach_to_post_type: string;
    set_featured: boolean;
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
}, {
    target_id: string;
    source: "base64" | "url" | "local_path";
    path?: string | undefined;
    url?: string | undefined;
    title?: string | undefined;
    data?: string | undefined;
    filename?: string | undefined;
    alt?: string | undefined;
    caption?: string | undefined;
    attach_to_post?: number | undefined;
    attach_to_post_type?: string | undefined;
    set_featured?: boolean | undefined;
}>;
type WpMediaUploadInput = z.infer<typeof WpMediaUploadInputSchema>;
declare const WpMediaUploadOutputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
type WpMediaUploadOutput = z.infer<typeof WpMediaUploadOutputSchema>;
declare const WpSiteBackupInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    action: z.ZodDefault<z.ZodEnum<["start", "status", "list", "inspect", "cancel", "delete", "download", "import"]>>;
    components: z.ZodOptional<z.ZodObject<{
        db: z.ZodOptional<z.ZodBoolean>;
        uploads: z.ZodOptional<z.ZodBoolean>;
        themes: z.ZodOptional<z.ZodBoolean>;
        plugins: z.ZodOptional<z.ZodBoolean>;
        muplugins: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    }, {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    }>>;
    compress: z.ZodOptional<z.ZodBoolean>;
    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    id: z.ZodOptional<z.ZodString>;
    entry: z.ZodOptional<z.ZodString>;
    max_bytes: z.ZodOptional<z.ZodNumber>;
    dest_path: z.ZodOptional<z.ZodString>;
    src_path: z.ZodOptional<z.ZodString>;
    chunk_bytes: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    action: "status" | "list" | "delete" | "inspect" | "start" | "cancel" | "download" | "import";
    target_id: string;
    id?: string | undefined;
    max_bytes?: number | undefined;
    components?: {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    } | undefined;
    compress?: boolean | undefined;
    exclude?: string[] | undefined;
    entry?: string | undefined;
    dest_path?: string | undefined;
    src_path?: string | undefined;
    chunk_bytes?: number | undefined;
}, {
    target_id: string;
    id?: string | undefined;
    action?: "status" | "list" | "delete" | "inspect" | "start" | "cancel" | "download" | "import" | undefined;
    max_bytes?: number | undefined;
    components?: {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    } | undefined;
    compress?: boolean | undefined;
    exclude?: string[] | undefined;
    entry?: string | undefined;
    dest_path?: string | undefined;
    src_path?: string | undefined;
    chunk_bytes?: number | undefined;
}>;
type WpSiteBackupInput = z.infer<typeof WpSiteBackupInputSchema>;
declare const WpSiteBackupOutputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
type WpSiteBackupOutput = z.infer<typeof WpSiteBackupOutputSchema>;
declare const WpSiteRestoreInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    action: z.ZodDefault<z.ZodEnum<["start", "status"]>>;
    id: z.ZodOptional<z.ZodString>;
    confirm: z.ZodDefault<z.ZodBoolean>;
    components: z.ZodOptional<z.ZodObject<{
        db: z.ZodOptional<z.ZodBoolean>;
        files: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        db?: boolean | undefined;
        files?: boolean | undefined;
    }, {
        db?: boolean | undefined;
        files?: boolean | undefined;
    }>>;
    search_replace: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    path_prefix: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: "status" | "start";
    target_id: string;
    confirm: boolean;
    id?: string | undefined;
    components?: {
        db?: boolean | undefined;
        files?: boolean | undefined;
    } | undefined;
    search_replace?: Record<string, string> | undefined;
    path_prefix?: string | undefined;
}, {
    target_id: string;
    id?: string | undefined;
    action?: "status" | "start" | undefined;
    confirm?: boolean | undefined;
    components?: {
        db?: boolean | undefined;
        files?: boolean | undefined;
    } | undefined;
    search_replace?: Record<string, string> | undefined;
    path_prefix?: string | undefined;
}>;
type WpSiteRestoreInput = z.infer<typeof WpSiteRestoreInputSchema>;
declare const WpSiteRestoreOutputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
type WpSiteRestoreOutput = z.infer<typeof WpSiteRestoreOutputSchema>;
declare const MigrateSiteInputSchema: z.ZodObject<{
    source_target_id: z.ZodString;
    dest_target_id: z.ZodString;
    allow_destructive: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<true>, z.ZodLiteral<"true">]>, true, true | "true">;
    confirm: z.ZodDefault<z.ZodBoolean>;
    components: z.ZodOptional<z.ZodObject<{
        db: z.ZodOptional<z.ZodBoolean>;
        uploads: z.ZodOptional<z.ZodBoolean>;
        themes: z.ZodOptional<z.ZodBoolean>;
        plugins: z.ZodOptional<z.ZodBoolean>;
        muplugins: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    }, {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    }>>;
    work_path: z.ZodOptional<z.ZodString>;
    chunk_bytes: z.ZodOptional<z.ZodNumber>;
    timeout_ms: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    allow_destructive: true;
    confirm: boolean;
    source_target_id: string;
    dest_target_id: string;
    timeout_ms?: number | undefined;
    components?: {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    } | undefined;
    chunk_bytes?: number | undefined;
    work_path?: string | undefined;
}, {
    allow_destructive: true | "true";
    source_target_id: string;
    dest_target_id: string;
    timeout_ms?: number | undefined;
    confirm?: boolean | undefined;
    components?: {
        db?: boolean | undefined;
        uploads?: boolean | undefined;
        themes?: boolean | undefined;
        plugins?: boolean | undefined;
        muplugins?: boolean | undefined;
    } | undefined;
    chunk_bytes?: number | undefined;
    work_path?: string | undefined;
}>;
type MigrateSiteInput = z.infer<typeof MigrateSiteInputSchema>;
declare const MigrateSiteOutputSchema: z.ZodObject<{
    run_id: z.ZodString;
    ok: z.ZodBoolean;
    dest_rollback_backup_id: z.ZodString;
    source_backup_id: z.ZodString;
    steps: z.ZodArray<z.ZodObject<{
        step: z.ZodString;
        ok: z.ZodBoolean;
        detail: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }, {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }>, "many">;
    report_path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ok: boolean;
    run_id: string;
    report_path: string;
    steps: {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }[];
    dest_rollback_backup_id: string;
    source_backup_id: string;
}, {
    ok: boolean;
    run_id: string;
    report_path: string;
    steps: {
        ok: boolean;
        step: string;
        detail?: string | undefined;
    }[];
    dest_rollback_backup_id: string;
    source_backup_id: string;
}>;
type MigrateSiteOutput = z.infer<typeof MigrateSiteOutputSchema>;
declare const WpCustomInitInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    activate: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    activate: boolean;
}, {
    target_id: string;
    activate?: boolean | undefined;
}>;
type WpCustomInitInput = z.infer<typeof WpCustomInitInputSchema>;
declare const WpCustomInitOutputSchema: z.ZodObject<{
    plugin_dir: z.ZodString;
    files_written: z.ZodNumber;
    was_already_installed: z.ZodBoolean;
    activated: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    files_written: number;
    plugin_dir: string;
    was_already_installed: boolean;
    activated: boolean;
}, {
    files_written: number;
    plugin_dir: string;
    was_already_installed: boolean;
    activated: boolean;
}>;
type WpCustomInitOutput = z.infer<typeof WpCustomInitOutputSchema>;
declare const WpCustomTaskScaffoldInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    task_id: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    settings: z.ZodDefault<z.ZodArray<z.ZodObject<{
        key: z.ZodString;
        type: z.ZodEnum<["text", "email", "url", "number", "textarea", "checkbox", "select"]>;
        label: z.ZodString;
        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
        help: z.ZodOptional<z.ZodString>;
        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }, {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }>, "many">>;
    hooks_body: z.ZodString;
    extra_methods: z.ZodOptional<z.ZodString>;
    auto_init: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    description: string;
    title: string;
    target_id: string;
    settings: {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }[];
    task_id: string;
    hooks_body: string;
    auto_init: boolean;
    extra_methods?: string | undefined;
}, {
    description: string;
    title: string;
    target_id: string;
    task_id: string;
    hooks_body: string;
    settings?: {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }[] | undefined;
    extra_methods?: string | undefined;
    auto_init?: boolean | undefined;
}>;
type WpCustomTaskScaffoldInput = z.infer<typeof WpCustomTaskScaffoldInputSchema>;
declare const WpCustomTaskScaffoldOutputSchema: z.ZodObject<{
    task_id: z.ZodString;
    title: z.ZodString;
    module_path: z.ZodString;
    bytes_written: z.ZodNumber;
    plugin_initialized: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    bytes_written: number;
    title: string;
    task_id: string;
    module_path: string;
    plugin_initialized: boolean;
}, {
    bytes_written: number;
    title: string;
    task_id: string;
    module_path: string;
    plugin_initialized: boolean;
}>;
type WpCustomTaskScaffoldOutput = z.infer<typeof WpCustomTaskScaffoldOutputSchema>;
declare const WpCustomTaskListInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type WpCustomTaskListInput = z.infer<typeof WpCustomTaskListInputSchema>;
declare const WpCustomTaskListOutputSchema: z.ZodObject<{
    plugin_installed: z.ZodBoolean;
    tasks: z.ZodArray<z.ZodObject<{
        task_id: z.ZodString;
        title: z.ZodString;
        description: z.ZodString;
        enabled: z.ZodBoolean;
        module_path: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        description: string;
        title: string;
        enabled: boolean;
        task_id: string;
        module_path: string;
    }, {
        description: string;
        title: string;
        enabled: boolean;
        task_id: string;
        module_path: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    plugin_installed: boolean;
    tasks: {
        description: string;
        title: string;
        enabled: boolean;
        task_id: string;
        module_path: string;
    }[];
}, {
    plugin_installed: boolean;
    tasks: {
        description: string;
        title: string;
        enabled: boolean;
        task_id: string;
        module_path: string;
    }[];
}>;
type WpCustomTaskListOutput = z.infer<typeof WpCustomTaskListOutputSchema>;
declare const WpCustomTaskToggleInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    task_id: z.ZodString;
    enabled: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    target_id: string;
    task_id: string;
}, {
    enabled: boolean;
    target_id: string;
    task_id: string;
}>;
type WpCustomTaskToggleInput = z.infer<typeof WpCustomTaskToggleInputSchema>;
declare const WpCustomTaskToggleOutputSchema: z.ZodObject<{
    task_id: z.ZodString;
    enabled: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    task_id: string;
}, {
    enabled: boolean;
    task_id: string;
}>;
type WpCustomTaskToggleOutput = z.infer<typeof WpCustomTaskToggleOutputSchema>;
declare const WpCustomTaskUpdateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    task_id: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
        key: z.ZodString;
        type: z.ZodEnum<["text", "email", "url", "number", "textarea", "checkbox", "select"]>;
        label: z.ZodString;
        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
        help: z.ZodOptional<z.ZodString>;
        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }, {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }>, "many">>;
    hooks_body: z.ZodOptional<z.ZodString>;
    extra_methods: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    task_id: string;
    description?: string | undefined;
    title?: string | undefined;
    settings?: {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }[] | undefined;
    hooks_body?: string | undefined;
    extra_methods?: string | undefined;
}, {
    target_id: string;
    task_id: string;
    description?: string | undefined;
    title?: string | undefined;
    settings?: {
        type: "number" | "url" | "email" | "text" | "textarea" | "checkbox" | "select";
        key: string;
        label: string;
        default?: string | number | boolean | undefined;
        options?: Record<string, string> | undefined;
        help?: string | undefined;
    }[] | undefined;
    hooks_body?: string | undefined;
    extra_methods?: string | undefined;
}>;
type WpCustomTaskUpdateInput = z.infer<typeof WpCustomTaskUpdateInputSchema>;
declare const WpCustomTaskUpdateOutputSchema: z.ZodObject<{
    task_id: z.ZodString;
    module_path: z.ZodString;
    bytes_written: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    bytes_written: number;
    task_id: string;
    module_path: string;
}, {
    bytes_written: number;
    task_id: string;
    module_path: string;
}>;
type WpCustomTaskUpdateOutput = z.infer<typeof WpCustomTaskUpdateOutputSchema>;
declare const WpCustomTaskRemoveInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    task_id: z.ZodString;
    run_uninstall: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    task_id: string;
    run_uninstall: boolean;
}, {
    target_id: string;
    task_id: string;
    run_uninstall?: boolean | undefined;
}>;
type WpCustomTaskRemoveInput = z.infer<typeof WpCustomTaskRemoveInputSchema>;
declare const WpCustomTaskRemoveOutputSchema: z.ZodObject<{
    task_id: z.ZodString;
    module_path: z.ZodString;
    uninstall_run: z.ZodBoolean;
    file_deleted: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    task_id: string;
    module_path: string;
    uninstall_run: boolean;
    file_deleted: boolean;
}, {
    task_id: string;
    module_path: string;
    uninstall_run: boolean;
    file_deleted: boolean;
}>;
type WpCustomTaskRemoveOutput = z.infer<typeof WpCustomTaskRemoveOutputSchema>;
declare const WpBuilderDetectInputSchema: z.ZodObject<{
    target_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    target_id: string;
}, {
    target_id: string;
}>;
type WpBuilderDetectInput = z.infer<typeof WpBuilderDetectInputSchema>;
declare const WpBuilderDetectOutputSchema: z.ZodObject<{
    active_builders: z.ZodArray<z.ZodObject<{
        slug: z.ZodEnum<["elementor", "bricks", "divi", "oxygen", "gutenberg", "beaver-builder", "visual-composer", "breakdance", "brizy"]>;
        version: z.ZodString;
        capabilities: z.ZodArray<z.ZodString, "many">;
        pro: z.ZodBoolean;
        supported: z.ZodBoolean;
        write_support: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        version: string;
        slug: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy";
        capabilities: string[];
        pro: boolean;
        supported: boolean;
        write_support: boolean;
    }, {
        version: string;
        slug: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy";
        capabilities: string[];
        pro: boolean;
        supported: boolean;
        write_support: boolean;
    }>, "many">;
    primary: z.ZodNullable<z.ZodEnum<["elementor", "bricks", "divi", "oxygen", "gutenberg", "beaver-builder", "visual-composer", "breakdance", "brizy"]>>;
}, "strip", z.ZodTypeAny, {
    active_builders: {
        version: string;
        slug: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy";
        capabilities: string[];
        pro: boolean;
        supported: boolean;
        write_support: boolean;
    }[];
    primary: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy" | null;
}, {
    active_builders: {
        version: string;
        slug: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy";
        capabilities: string[];
        pro: boolean;
        supported: boolean;
        write_support: boolean;
    }[];
    primary: "elementor" | "bricks" | "divi" | "oxygen" | "gutenberg" | "beaver-builder" | "visual-composer" | "breakdance" | "brizy" | null;
}>;
type WpBuilderDetectOutput = z.infer<typeof WpBuilderDetectOutputSchema>;
declare const WpElementorHtmlAuditInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    threshold_pct: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    target_id: string;
    threshold_pct: number;
}, {
    post_id: number;
    target_id: string;
    threshold_pct?: number | undefined;
}>;
type WpElementorHtmlAuditInput = z.infer<typeof WpElementorHtmlAuditInputSchema>;
declare const WpElementorHtmlAuditOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    total_widgets: z.ZodNumber;
    html_widgets: z.ZodNumber;
    html_widget_pct: z.ZodNumber;
    over_threshold: z.ZodBoolean;
    threshold_pct: z.ZodNumber;
    widget_type_counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
    suggestions: z.ZodArray<z.ZodObject<{
        widget_id: z.ZodString;
        reason: z.ZodString;
        suggested_widget: z.ZodOptional<z.ZodString>;
        suggested_pattern: z.ZodOptional<z.ZodString>;
        fidelity_risk: z.ZodOptional<z.ZodEnum<["low", "high"]>>;
        would_lose: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        reason: string;
        widget_id: string;
        suggested_widget?: string | undefined;
        suggested_pattern?: string | undefined;
        fidelity_risk?: "low" | "high" | undefined;
        would_lose?: string[] | undefined;
    }, {
        reason: string;
        widget_id: string;
        suggested_widget?: string | undefined;
        suggested_pattern?: string | undefined;
        fidelity_risk?: "low" | "high" | undefined;
        would_lose?: string[] | undefined;
    }>, "many">;
    lossy_widgets: z.ZodNumber;
    guidance: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    threshold_pct: number;
    total_widgets: number;
    html_widgets: number;
    html_widget_pct: number;
    over_threshold: boolean;
    widget_type_counts: Record<string, number>;
    suggestions: {
        reason: string;
        widget_id: string;
        suggested_widget?: string | undefined;
        suggested_pattern?: string | undefined;
        fidelity_risk?: "low" | "high" | undefined;
        would_lose?: string[] | undefined;
    }[];
    lossy_widgets: number;
    guidance?: string | undefined;
}, {
    post_id: number;
    threshold_pct: number;
    total_widgets: number;
    html_widgets: number;
    html_widget_pct: number;
    over_threshold: boolean;
    widget_type_counts: Record<string, number>;
    suggestions: {
        reason: string;
        widget_id: string;
        suggested_widget?: string | undefined;
        suggested_pattern?: string | undefined;
        fidelity_risk?: "low" | "high" | undefined;
        would_lose?: string[] | undefined;
    }[];
    lossy_widgets: number;
    guidance?: string | undefined;
}>;
type WpElementorHtmlAuditOutput = z.infer<typeof WpElementorHtmlAuditOutputSchema>;
declare const WpElementorSectionInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    action: z.ZodEnum<["get", "replace", "insert", "delete"]>;
    section_id: z.ZodOptional<z.ZodString>;
    match_class: z.ZodOptional<z.ZodString>;
    section: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    position: z.ZodDefault<z.ZodEnum<["before", "after", "start", "end"]>>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    action: "replace" | "get" | "delete" | "insert";
    target_id: string;
    confirm: boolean;
    position: "end" | "start" | "before" | "after";
    section_id?: string | undefined;
    match_class?: string | undefined;
    section?: Record<string, unknown> | undefined;
}, {
    post_id: number;
    action: "replace" | "get" | "delete" | "insert";
    target_id: string;
    confirm?: boolean | undefined;
    section_id?: string | undefined;
    match_class?: string | undefined;
    section?: Record<string, unknown> | undefined;
    position?: "end" | "start" | "before" | "after" | undefined;
}>;
type WpElementorSectionInput = z.infer<typeof WpElementorSectionInputSchema>;
declare const WpElementorSectionOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    action: z.ZodString;
    matched: z.ZodNumber;
    matched_ids: z.ZodArray<z.ZodString, "many">;
    total_sections: z.ZodNumber;
    bytes_written: z.ZodOptional<z.ZodNumber>;
    backup_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    flushed: z.ZodOptional<z.ZodBoolean>;
    sections: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    action: string;
    matched: number;
    matched_ids: string[];
    total_sections: number;
    bytes_written?: number | undefined;
    backup_path?: string | null | undefined;
    sections?: unknown[] | undefined;
    flushed?: boolean | undefined;
}, {
    post_id: number;
    action: string;
    matched: number;
    matched_ids: string[];
    total_sections: number;
    bytes_written?: number | undefined;
    backup_path?: string | null | undefined;
    sections?: unknown[] | undefined;
    flushed?: boolean | undefined;
}>;
type WpElementorSectionOutput = z.infer<typeof WpElementorSectionOutputSchema>;
declare const WpElementorRestoreInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodNumber;
    action: z.ZodDefault<z.ZodEnum<["list", "restore"]>>;
    backup_path: z.ZodOptional<z.ZodString>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    action: "list" | "restore";
    target_id: string;
    confirm: boolean;
    backup_path?: string | undefined;
}, {
    post_id: number;
    target_id: string;
    backup_path?: string | undefined;
    action?: "list" | "restore" | undefined;
    confirm?: boolean | undefined;
}>;
type WpElementorRestoreInput = z.infer<typeof WpElementorRestoreInputSchema>;
declare const WpElementorRestoreOutputSchema: z.ZodObject<{
    post_id: z.ZodNumber;
    action: z.ZodString;
    backups: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        bytes: z.ZodNumber;
        mtime: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        path: string;
        bytes: number;
        mtime: number;
    }, {
        path: string;
        bytes: number;
        mtime: number;
    }>, "many">>;
    restored_from: z.ZodOptional<z.ZodString>;
    bytes_written: z.ZodOptional<z.ZodNumber>;
    pre_restore_backup: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    flushed: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    post_id: number;
    action: string;
    bytes_written?: number | undefined;
    flushed?: boolean | undefined;
    backups?: {
        path: string;
        bytes: number;
        mtime: number;
    }[] | undefined;
    restored_from?: string | undefined;
    pre_restore_backup?: string | null | undefined;
}, {
    post_id: number;
    action: string;
    bytes_written?: number | undefined;
    flushed?: boolean | undefined;
    backups?: {
        path: string;
        bytes: number;
        mtime: number;
    }[] | undefined;
    restored_from?: string | undefined;
    pre_restore_backup?: string | null | undefined;
}>;
type WpElementorRestoreOutput = z.infer<typeof WpElementorRestoreOutputSchema>;
declare const WpRenderGetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    post_id: z.ZodOptional<z.ZodNumber>;
    url: z.ZodOptional<z.ZodString>;
    grep: z.ZodOptional<z.ZodString>;
    context: z.ZodDefault<z.ZodNumber>;
    ignore_case: z.ZodDefault<z.ZodBoolean>;
    max_bytes: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    target_id: string;
    max_bytes: number;
    context: number;
    ignore_case: boolean;
    url?: string | undefined;
    post_id?: number | undefined;
    grep?: string | undefined;
}, {
    target_id: string;
    url?: string | undefined;
    post_id?: number | undefined;
    max_bytes?: number | undefined;
    context?: number | undefined;
    grep?: string | undefined;
    ignore_case?: boolean | undefined;
}>;
type WpRenderGetInput = z.infer<typeof WpRenderGetInputSchema>;
declare const WpRenderGetOutputSchema: z.ZodObject<{
    url: z.ZodString;
    status: z.ZodNumber;
    total_bytes: z.ZodNumber;
    returned_bytes: z.ZodNumber;
    truncated: z.ZodBoolean;
    matched_lines: z.ZodOptional<z.ZodNumber>;
    content: z.ZodString;
}, "strip", z.ZodTypeAny, {
    status: number;
    content: string;
    url: string;
    truncated: boolean;
    total_bytes: number;
    returned_bytes: number;
    matched_lines?: number | undefined;
}, {
    status: number;
    content: string;
    url: string;
    truncated: boolean;
    total_bytes: number;
    returned_bytes: number;
    matched_lines?: number | undefined;
}>;
type WpRenderGetOutput = z.infer<typeof WpRenderGetOutputSchema>;
declare const TermInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    action: z.ZodDefault<z.ZodEnum<["list", "create", "ensure"]>>;
    taxonomy: z.ZodDefault<z.ZodString>;
    rest_base: z.ZodOptional<z.ZodString>;
    name: z.ZodOptional<z.ZodString>;
    slug: z.ZodOptional<z.ZodString>;
    parent: z.ZodOptional<z.ZodNumber>;
    description: z.ZodOptional<z.ZodString>;
    per_page: z.ZodDefault<z.ZodNumber>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    action: "list" | "create" | "ensure";
    target_id: string;
    per_page: number;
    confirm: boolean;
    taxonomy: string;
    name?: string | undefined;
    slug?: string | undefined;
    description?: string | undefined;
    rest_base?: string | undefined;
    parent?: number | undefined;
}, {
    target_id: string;
    name?: string | undefined;
    slug?: string | undefined;
    description?: string | undefined;
    action?: "list" | "create" | "ensure" | undefined;
    per_page?: number | undefined;
    confirm?: boolean | undefined;
    taxonomy?: string | undefined;
    rest_base?: string | undefined;
    parent?: number | undefined;
}>;
type TermInput = z.infer<typeof TermInputSchema>;
declare const TermOutputSchema: z.ZodObject<{
    action: z.ZodString;
    taxonomy: z.ZodString;
    source: z.ZodEnum<["wp_cli", "rest"]>;
    terms: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
    term_id: z.ZodOptional<z.ZodNumber>;
    existed: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    action: string;
    source: "rest" | "wp_cli";
    taxonomy: string;
    terms?: Record<string, unknown>[] | undefined;
    term_id?: number | undefined;
    existed?: boolean | undefined;
}, {
    action: string;
    source: "rest" | "wp_cli";
    taxonomy: string;
    terms?: Record<string, unknown>[] | undefined;
    term_id?: number | undefined;
    existed?: boolean | undefined;
}>;
type TermOutput = z.infer<typeof TermOutputSchema>;
declare const UserWriteInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    action: z.ZodEnum<["create", "update", "delete"]>;
    id: z.ZodOptional<z.ZodNumber>;
    username: z.ZodOptional<z.ZodString>;
    email: z.ZodOptional<z.ZodString>;
    password: z.ZodOptional<z.ZodString>;
    role: z.ZodOptional<z.ZodString>;
    display_name: z.ZodOptional<z.ZodString>;
    reassign_to: z.ZodOptional<z.ZodNumber>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    action: "delete" | "create" | "update";
    target_id: string;
    confirm: boolean;
    id?: number | undefined;
    username?: string | undefined;
    password?: string | undefined;
    role?: string | undefined;
    email?: string | undefined;
    display_name?: string | undefined;
    reassign_to?: number | undefined;
}, {
    action: "delete" | "create" | "update";
    target_id: string;
    id?: number | undefined;
    username?: string | undefined;
    password?: string | undefined;
    confirm?: boolean | undefined;
    role?: string | undefined;
    email?: string | undefined;
    display_name?: string | undefined;
    reassign_to?: number | undefined;
}>;
type UserWriteInput = z.infer<typeof UserWriteInputSchema>;
declare const UserWriteOutputSchema: z.ZodObject<{
    action: z.ZodString;
    source: z.ZodEnum<["wp_cli", "rest"]>;
    user_id: z.ZodOptional<z.ZodNumber>;
    reassigned_to: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    action: string;
    source: "rest" | "wp_cli";
    user_id?: number | undefined;
    reassigned_to?: number | undefined;
}, {
    action: string;
    source: "rest" | "wp_cli";
    user_id?: number | undefined;
    reassigned_to?: number | undefined;
}>;
type UserWriteOutput = z.infer<typeof UserWriteOutputSchema>;
declare const CommentInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    action: z.ZodDefault<z.ZodEnum<["list", "moderate", "delete"]>>;
    id: z.ZodOptional<z.ZodNumber>;
    status: z.ZodOptional<z.ZodEnum<["approve", "hold", "spam", "trash"]>>;
    post: z.ZodOptional<z.ZodNumber>;
    per_page: z.ZodDefault<z.ZodNumber>;
    force: z.ZodDefault<z.ZodBoolean>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    action: "list" | "delete" | "moderate";
    target_id: string;
    per_page: number;
    confirm: boolean;
    force: boolean;
    status?: "approve" | "hold" | "spam" | "trash" | undefined;
    id?: number | undefined;
    post?: number | undefined;
}, {
    target_id: string;
    status?: "approve" | "hold" | "spam" | "trash" | undefined;
    id?: number | undefined;
    action?: "list" | "delete" | "moderate" | undefined;
    post?: number | undefined;
    per_page?: number | undefined;
    confirm?: boolean | undefined;
    force?: boolean | undefined;
}>;
type CommentInput = z.infer<typeof CommentInputSchema>;
declare const CommentOutputSchema: z.ZodObject<{
    action: z.ZodString;
    source: z.ZodEnum<["wp_cli", "rest"]>;
    comments: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
    comment_id: z.ZodOptional<z.ZodNumber>;
    status: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: string;
    source: "rest" | "wp_cli";
    status?: string | undefined;
    comments?: Record<string, unknown>[] | undefined;
    comment_id?: number | undefined;
}, {
    action: string;
    source: "rest" | "wp_cli";
    status?: string | undefined;
    comments?: Record<string, unknown>[] | undefined;
    comment_id?: number | undefined;
}>;
type CommentOutput = z.infer<typeof CommentOutputSchema>;
declare const CptScaffoldInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    slug: z.ZodString;
    singular: z.ZodString;
    plural: z.ZodString;
    public: z.ZodDefault<z.ZodBoolean>;
    show_in_rest: z.ZodDefault<z.ZodBoolean>;
    has_archive: z.ZodDefault<z.ZodBoolean>;
    supports: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    slug: string;
    target_id: string;
    confirm: boolean;
    singular: string;
    plural: string;
    public: boolean;
    show_in_rest: boolean;
    has_archive: boolean;
    supports?: string[] | undefined;
}, {
    slug: string;
    target_id: string;
    singular: string;
    plural: string;
    confirm?: boolean | undefined;
    public?: boolean | undefined;
    show_in_rest?: boolean | undefined;
    has_archive?: boolean | undefined;
    supports?: string[] | undefined;
}>;
type CptScaffoldInput = z.infer<typeof CptScaffoldInputSchema>;
declare const CptScaffoldOutputSchema: z.ZodObject<{
    slug: z.ZodString;
    plugin_file: z.ZodString;
    activated: z.ZodBoolean;
    rest_verified: z.ZodBoolean;
    rest_base: z.ZodString;
}, "strip", z.ZodTypeAny, {
    slug: string;
    activated: boolean;
    rest_base: string;
    plugin_file: string;
    rest_verified: boolean;
}, {
    slug: string;
    activated: boolean;
    rest_base: string;
    plugin_file: string;
    rest_verified: boolean;
}>;
type CptScaffoldOutput = z.infer<typeof CptScaffoldOutputSchema>;
declare const MaintenanceUpdateInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    scope: z.ZodEnum<["plugin", "theme", "core"]>;
    slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    auto_rollback: z.ZodDefault<z.ZodBoolean>;
    confirm_production: z.ZodDefault<z.ZodBoolean>;
    backup_id: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    scope: "core" | "plugin" | "theme";
    target_id: string;
    auto_rollback: boolean;
    confirm_production: boolean;
    slugs?: string[] | undefined;
    backup_id?: string | undefined;
}, {
    scope: "core" | "plugin" | "theme";
    target_id: string;
    slugs?: string[] | undefined;
    auto_rollback?: boolean | undefined;
    confirm_production?: boolean | undefined;
    backup_id?: string | undefined;
}>;
type MaintenanceUpdateInput = z.infer<typeof MaintenanceUpdateInputSchema>;
declare const MaintenanceUpdateOutputSchema: z.ZodObject<{
    scope: z.ZodString;
    updated: z.ZodArray<z.ZodString, "many">;
    backup_id: z.ZodString;
    health_ok: z.ZodBoolean;
    rolled_back: z.ZodBoolean;
    reason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    scope: string;
    updated: string[];
    backup_id: string;
    health_ok: boolean;
    rolled_back: boolean;
    reason?: string | undefined;
}, {
    scope: string;
    updated: string[];
    backup_id: string;
    health_ok: boolean;
    rolled_back: boolean;
    reason?: string | undefined;
}>;
type MaintenanceUpdateOutput = z.infer<typeof MaintenanceUpdateOutputSchema>;
declare const HtaccessEditInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    content: z.ZodString;
    confirm_production: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    content: string;
    target_id: string;
    confirm_production: boolean;
}, {
    content: string;
    target_id: string;
    confirm_production?: boolean | undefined;
}>;
type HtaccessEditInput = z.infer<typeof HtaccessEditInputSchema>;
declare const HtaccessEditOutputSchema: z.ZodObject<{
    written: z.ZodBoolean;
    backup_path: z.ZodString;
    health_ok: z.ZodBoolean;
    rolled_back: z.ZodBoolean;
    reason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    written: boolean;
    backup_path: string;
    health_ok: boolean;
    rolled_back: boolean;
    reason?: string | undefined;
}, {
    written: boolean;
    backup_path: string;
    health_ok: boolean;
    rolled_back: boolean;
    reason?: string | undefined;
}>;
type HtaccessEditOutput = z.infer<typeof HtaccessEditOutputSchema>;
declare const RedirectSetInputSchema: z.ZodObject<{
    target_id: z.ZodString;
    source: z.ZodString;
    target: z.ZodString;
    code: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<307>, z.ZodLiteral<410>]>>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    code: 301 | 302 | 307 | 410;
    target_id: string;
    source: string;
    confirm: boolean;
    target: string;
}, {
    target_id: string;
    source: string;
    target: string;
    code?: 301 | 302 | 307 | 410 | undefined;
    confirm?: boolean | undefined;
}>;
type RedirectSetInput = z.infer<typeof RedirectSetInputSchema>;
declare const RedirectSetOutputSchema: z.ZodObject<{
    backend: z.ZodString;
    source: z.ZodString;
    target: z.ZodString;
    code: z.ZodNumber;
    created: z.ZodBoolean;
    id: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    code: number;
    created: boolean;
    source: string;
    target: string;
    backend: string;
    id?: number | undefined;
}, {
    code: number;
    created: boolean;
    source: string;
    target: string;
    backend: string;
    id?: number | undefined;
}>;
type RedirectSetOutput = z.infer<typeof RedirectSetOutputSchema>;

type tools_AcfReadInput = AcfReadInput;
declare const tools_AcfReadInputSchema: typeof AcfReadInputSchema;
type tools_AcfReadOutput = AcfReadOutput;
declare const tools_AcfReadOutputSchema: typeof AcfReadOutputSchema;
type tools_AcfWriteInput = AcfWriteInput;
declare const tools_AcfWriteInputSchema: typeof AcfWriteInputSchema;
type tools_AcfWriteOutput = AcfWriteOutput;
declare const tools_AcfWriteOutputSchema: typeof AcfWriteOutputSchema;
type tools_AuditManyInput = AuditManyInput;
declare const tools_AuditManyInputSchema: typeof AuditManyInputSchema;
type tools_AuditManyOutput = AuditManyOutput;
declare const tools_AuditManyOutputSchema: typeof AuditManyOutputSchema;
type tools_AuditSecurityInput = AuditSecurityInput;
declare const tools_AuditSecurityInputSchema: typeof AuditSecurityInputSchema;
type tools_AuditSecurityOutput = AuditSecurityOutput;
declare const tools_AuditSecurityOutputSchema: typeof AuditSecurityOutputSchema;
type tools_BackupCreateInput = BackupCreateInput;
declare const tools_BackupCreateInputSchema: typeof BackupCreateInputSchema;
type tools_BackupCreateOutput = BackupCreateOutput;
declare const tools_BackupCreateOutputSchema: typeof BackupCreateOutputSchema;
type tools_BackupRestoreInput = BackupRestoreInput;
declare const tools_BackupRestoreInputSchema: typeof BackupRestoreInputSchema;
type tools_BackupRestoreOutput = BackupRestoreOutput;
declare const tools_BackupRestoreOutputSchema: typeof BackupRestoreOutputSchema;
type tools_BricksReadInput = BricksReadInput;
declare const tools_BricksReadInputSchema: typeof BricksReadInputSchema;
type tools_BricksReadOutput = BricksReadOutput;
declare const tools_BricksReadOutputSchema: typeof BricksReadOutputSchema;
type tools_BricksWriteInput = BricksWriteInput;
declare const tools_BricksWriteInputSchema: typeof BricksWriteInputSchema;
type tools_BricksWriteOutput = BricksWriteOutput;
declare const tools_BricksWriteOutputSchema: typeof BricksWriteOutputSchema;
type tools_CacheToolInput = CacheToolInput;
declare const tools_CacheToolInputSchema: typeof CacheToolInputSchema;
type tools_CacheToolOutput = CacheToolOutput;
declare const tools_CacheToolOutputSchema: typeof CacheToolOutputSchema;
type tools_CloneInput = CloneInput;
declare const tools_CloneInputSchema: typeof CloneInputSchema;
type tools_CloneOutput = CloneOutput;
declare const tools_CloneOutputSchema: typeof CloneOutputSchema;
type tools_CommentInput = CommentInput;
declare const tools_CommentInputSchema: typeof CommentInputSchema;
type tools_CommentOutput = CommentOutput;
declare const tools_CommentOutputSchema: typeof CommentOutputSchema;
type tools_ConnectDockerInput = ConnectDockerInput;
declare const tools_ConnectDockerInputSchema: typeof ConnectDockerInputSchema;
type tools_ConnectDockerOutput = ConnectDockerOutput;
declare const tools_ConnectDockerOutputSchema: typeof ConnectDockerOutputSchema;
type tools_ConnectLocalInput = ConnectLocalInput;
declare const tools_ConnectLocalInputSchema: typeof ConnectLocalInputSchema;
type tools_ConnectLocalOutput = ConnectLocalOutput;
declare const tools_ConnectLocalOutputSchema: typeof ConnectLocalOutputSchema;
type tools_ConnectRestInput = ConnectRestInput;
declare const tools_ConnectRestInputSchema: typeof ConnectRestInputSchema;
type tools_ConnectRestOutput = ConnectRestOutput;
declare const tools_ConnectRestOutputSchema: typeof ConnectRestOutputSchema;
type tools_ConnectSshInput = ConnectSshInput;
declare const tools_ConnectSshInputSchema: typeof ConnectSshInputSchema;
type tools_ConnectSshOutput = ConnectSshOutput;
declare const tools_ConnectSshOutputSchema: typeof ConnectSshOutputSchema;
type tools_CptScaffoldInput = CptScaffoldInput;
declare const tools_CptScaffoldInputSchema: typeof CptScaffoldInputSchema;
type tools_CptScaffoldOutput = CptScaffoldOutput;
declare const tools_CptScaffoldOutputSchema: typeof CptScaffoldOutputSchema;
type tools_CronToolInput = CronToolInput;
declare const tools_CronToolInputSchema: typeof CronToolInputSchema;
type tools_CronToolOutput = CronToolOutput;
declare const tools_CronToolOutputSchema: typeof CronToolOutputSchema;
type tools_DbQueryInput = DbQueryInput;
declare const tools_DbQueryInputSchema: typeof DbQueryInputSchema;
type tools_DbQueryOutput = DbQueryOutput;
declare const tools_DbQueryOutputSchema: typeof DbQueryOutputSchema;
type tools_DiagnoseInput = DiagnoseInput;
declare const tools_DiagnoseInputSchema: typeof DiagnoseInputSchema;
type tools_DiagnoseOutput = DiagnoseOutput;
declare const tools_DiagnoseOutputSchema: typeof DiagnoseOutputSchema;
type tools_DisconnectInput = DisconnectInput;
declare const tools_DisconnectInputSchema: typeof DisconnectInputSchema;
type tools_DisconnectOutput = DisconnectOutput;
declare const tools_DisconnectOutputSchema: typeof DisconnectOutputSchema;
type tools_DiviReadInput = DiviReadInput;
declare const tools_DiviReadInputSchema: typeof DiviReadInputSchema;
type tools_DiviReadOutput = DiviReadOutput;
declare const tools_DiviReadOutputSchema: typeof DiviReadOutputSchema;
type tools_DiviWriteInput = DiviWriteInput;
declare const tools_DiviWriteInputSchema: typeof DiviWriteInputSchema;
type tools_DiviWriteOutput = DiviWriteOutput;
declare const tools_DiviWriteOutputSchema: typeof DiviWriteOutputSchema;
type tools_ElementorReadInput = ElementorReadInput;
declare const tools_ElementorReadInputSchema: typeof ElementorReadInputSchema;
type tools_ElementorReadOutput = ElementorReadOutput;
declare const tools_ElementorReadOutputSchema: typeof ElementorReadOutputSchema;
type tools_ElementorWriteInput = ElementorWriteInput;
declare const tools_ElementorWriteInputSchema: typeof ElementorWriteInputSchema;
type tools_ElementorWriteOutput = ElementorWriteOutput;
declare const tools_ElementorWriteOutputSchema: typeof ElementorWriteOutputSchema;
type tools_ExecutePhpInput = ExecutePhpInput;
declare const tools_ExecutePhpInputSchema: typeof ExecutePhpInputSchema;
type tools_ExecutePhpOutput = ExecutePhpOutput;
declare const tools_ExecutePhpOutputSchema: typeof ExecutePhpOutputSchema;
type tools_FormsReadInput = FormsReadInput;
declare const tools_FormsReadInputSchema: typeof FormsReadInputSchema;
type tools_FormsReadOutput = FormsReadOutput;
declare const tools_FormsReadOutputSchema: typeof FormsReadOutputSchema;
type tools_FormsWriteInput = FormsWriteInput;
declare const tools_FormsWriteInputSchema: typeof FormsWriteInputSchema;
type tools_FormsWriteOutput = FormsWriteOutput;
declare const tools_FormsWriteOutputSchema: typeof FormsWriteOutputSchema;
type tools_HookStateInput = HookStateInput;
declare const tools_HookStateInputSchema: typeof HookStateInputSchema;
type tools_HookStateOutput = HookStateOutput;
declare const tools_HookStateOutputSchema: typeof HookStateOutputSchema;
type tools_HtaccessEditInput = HtaccessEditInput;
declare const tools_HtaccessEditInputSchema: typeof HtaccessEditInputSchema;
type tools_HtaccessEditOutput = HtaccessEditOutput;
declare const tools_HtaccessEditOutputSchema: typeof HtaccessEditOutputSchema;
type tools_IntrospectInput = IntrospectInput;
declare const tools_IntrospectInputSchema: typeof IntrospectInputSchema;
type tools_IntrospectOutput = IntrospectOutput;
declare const tools_IntrospectOutputSchema: typeof IntrospectOutputSchema;
type tools_MailTestInput = MailTestInput;
declare const tools_MailTestInputSchema: typeof MailTestInputSchema;
type tools_MailTestOutput = MailTestOutput;
declare const tools_MailTestOutputSchema: typeof MailTestOutputSchema;
type tools_MaintenanceUpdateInput = MaintenanceUpdateInput;
declare const tools_MaintenanceUpdateInputSchema: typeof MaintenanceUpdateInputSchema;
type tools_MaintenanceUpdateOutput = MaintenanceUpdateOutput;
declare const tools_MaintenanceUpdateOutputSchema: typeof MaintenanceUpdateOutputSchema;
type tools_MemoryListInput = MemoryListInput;
declare const tools_MemoryListInputSchema: typeof MemoryListInputSchema;
type tools_MemoryListOutput = MemoryListOutput;
declare const tools_MemoryListOutputSchema: typeof MemoryListOutputSchema;
type tools_MemoryNoteInput = MemoryNoteInput;
declare const tools_MemoryNoteInputSchema: typeof MemoryNoteInputSchema;
type tools_MemoryNoteOutput = MemoryNoteOutput;
declare const tools_MemoryNoteOutputSchema: typeof MemoryNoteOutputSchema;
type tools_MemoryRecallInput = MemoryRecallInput;
declare const tools_MemoryRecallInputSchema: typeof MemoryRecallInputSchema;
type tools_MemoryRecallOutput = MemoryRecallOutput;
declare const tools_MemoryRecallOutputSchema: typeof MemoryRecallOutputSchema;
type tools_MigrateDataInput = MigrateDataInput;
declare const tools_MigrateDataInputSchema: typeof MigrateDataInputSchema;
type tools_MigrateDataOutput = MigrateDataOutput;
declare const tools_MigrateDataOutputSchema: typeof MigrateDataOutputSchema;
type tools_MigrateDryrunInput = MigrateDryrunInput;
declare const tools_MigrateDryrunInputSchema: typeof MigrateDryrunInputSchema;
type tools_MigrateDryrunOutput = MigrateDryrunOutput;
declare const tools_MigrateDryrunOutputSchema: typeof MigrateDryrunOutputSchema;
type tools_MigrateSiteInput = MigrateSiteInput;
declare const tools_MigrateSiteInputSchema: typeof MigrateSiteInputSchema;
type tools_MigrateSiteOutput = MigrateSiteOutput;
declare const tools_MigrateSiteOutputSchema: typeof MigrateSiteOutputSchema;
type tools_OptionGetInput = OptionGetInput;
declare const tools_OptionGetInputSchema: typeof OptionGetInputSchema;
type tools_OptionGetOutput = OptionGetOutput;
declare const tools_OptionGetOutputSchema: typeof OptionGetOutputSchema;
type tools_OptionSetInput = OptionSetInput;
declare const tools_OptionSetInputSchema: typeof OptionSetInputSchema;
type tools_OptionSetOutput = OptionSetOutput;
declare const tools_OptionSetOutputSchema: typeof OptionSetOutputSchema;
type tools_OxygenReadInput = OxygenReadInput;
declare const tools_OxygenReadInputSchema: typeof OxygenReadInputSchema;
type tools_OxygenReadOutput = OxygenReadOutput;
declare const tools_OxygenReadOutputSchema: typeof OxygenReadOutputSchema;
type tools_OxygenWriteInput = OxygenWriteInput;
declare const tools_OxygenWriteInputSchema: typeof OxygenWriteInputSchema;
type tools_OxygenWriteOutput = OxygenWriteOutput;
declare const tools_OxygenWriteOutputSchema: typeof OxygenWriteOutputSchema;
type tools_PairInput = PairInput;
declare const tools_PairInputSchema: typeof PairInputSchema;
type tools_PairOutput = PairOutput;
declare const tools_PairOutputSchema: typeof PairOutputSchema;
type tools_PostCreateInput = PostCreateInput;
declare const tools_PostCreateInputSchema: typeof PostCreateInputSchema;
type tools_PostCreateOutput = PostCreateOutput;
declare const tools_PostCreateOutputSchema: typeof PostCreateOutputSchema;
type tools_PostGetInput = PostGetInput;
declare const tools_PostGetInputSchema: typeof PostGetInputSchema;
type tools_PostGetOutput = PostGetOutput;
declare const tools_PostGetOutputSchema: typeof PostGetOutputSchema;
type tools_PostListInput = PostListInput;
declare const tools_PostListInputSchema: typeof PostListInputSchema;
type tools_PostListOutput = PostListOutput;
declare const tools_PostListOutputSchema: typeof PostListOutputSchema;
type tools_PostUpdateInput = PostUpdateInput;
declare const tools_PostUpdateInputSchema: typeof PostUpdateInputSchema;
type tools_PostUpdateOutput = PostUpdateOutput;
declare const tools_PostUpdateOutputSchema: typeof PostUpdateOutputSchema;
declare const tools_ProdGuardStatusSchema: typeof ProdGuardStatusSchema;
type tools_RankMathReadInput = RankMathReadInput;
declare const tools_RankMathReadInputSchema: typeof RankMathReadInputSchema;
type tools_RankMathReadOutput = RankMathReadOutput;
declare const tools_RankMathReadOutputSchema: typeof RankMathReadOutputSchema;
type tools_RankMathWriteInput = RankMathWriteInput;
declare const tools_RankMathWriteInputSchema: typeof RankMathWriteInputSchema;
type tools_RankMathWriteOutput = RankMathWriteOutput;
declare const tools_RankMathWriteOutputSchema: typeof RankMathWriteOutputSchema;
type tools_RedirectSetInput = RedirectSetInput;
declare const tools_RedirectSetInputSchema: typeof RedirectSetInputSchema;
type tools_RedirectSetOutput = RedirectSetOutput;
declare const tools_RedirectSetOutputSchema: typeof RedirectSetOutputSchema;
type tools_RestDumpInput = RestDumpInput;
declare const tools_RestDumpInputSchema: typeof RestDumpInputSchema;
type tools_RestDumpOutput = RestDumpOutput;
declare const tools_RestDumpOutputSchema: typeof RestDumpOutputSchema;
type tools_RestRequestInput = RestRequestInput;
declare const tools_RestRequestInputSchema: typeof RestRequestInputSchema;
type tools_RestRequestOutput = RestRequestOutput;
declare const tools_RestRequestOutputSchema: typeof RestRequestOutputSchema;
declare const tools_RunIdSchema: typeof RunIdSchema;
type tools_ScaffoldBlockInput = ScaffoldBlockInput;
declare const tools_ScaffoldBlockInputSchema: typeof ScaffoldBlockInputSchema;
type tools_ScaffoldBlockOutput = ScaffoldBlockOutput;
declare const tools_ScaffoldBlockOutputSchema: typeof ScaffoldBlockOutputSchema;
type tools_ScaffoldPatternInput = ScaffoldPatternInput;
declare const tools_ScaffoldPatternInputSchema: typeof ScaffoldPatternInputSchema;
type tools_ScaffoldPatternOutput = ScaffoldPatternOutput;
declare const tools_ScaffoldPatternOutputSchema: typeof ScaffoldPatternOutputSchema;
type tools_ScaffoldPluginInput = ScaffoldPluginInput;
declare const tools_ScaffoldPluginInputSchema: typeof ScaffoldPluginInputSchema;
type tools_ScaffoldPluginOutput = ScaffoldPluginOutput;
declare const tools_ScaffoldPluginOutputSchema: typeof ScaffoldPluginOutputSchema;
type tools_ScaffoldThemeInput = ScaffoldThemeInput;
declare const tools_ScaffoldThemeInputSchema: typeof ScaffoldThemeInputSchema;
type tools_ScaffoldThemeOutput = ScaffoldThemeOutput;
declare const tools_ScaffoldThemeOutputSchema: typeof ScaffoldThemeOutputSchema;
type tools_SkillCatalogInput = SkillCatalogInput;
declare const tools_SkillCatalogInputSchema: typeof SkillCatalogInputSchema;
type tools_SkillCatalogOutput = SkillCatalogOutput;
declare const tools_SkillCatalogOutputSchema: typeof SkillCatalogOutputSchema;
type tools_SkillDeleteInput = SkillDeleteInput;
declare const tools_SkillDeleteInputSchema: typeof SkillDeleteInputSchema;
type tools_SkillDeleteOutput = SkillDeleteOutput;
declare const tools_SkillDeleteOutputSchema: typeof SkillDeleteOutputSchema;
type tools_SkillEditInput = SkillEditInput;
declare const tools_SkillEditInputSchema: typeof SkillEditInputSchema;
type tools_SkillEditOutput = SkillEditOutput;
declare const tools_SkillEditOutputSchema: typeof SkillEditOutputSchema;
type tools_SkillGetInput = SkillGetInput;
declare const tools_SkillGetInputSchema: typeof SkillGetInputSchema;
type tools_SkillGetOutput = SkillGetOutput;
declare const tools_SkillGetOutputSchema: typeof SkillGetOutputSchema;
type tools_SkillWriteInput = SkillWriteInput;
declare const tools_SkillWriteInputSchema: typeof SkillWriteInputSchema;
type tools_SkillWriteOutput = SkillWriteOutput;
declare const tools_SkillWriteOutputSchema: typeof SkillWriteOutputSchema;
type tools_TargetAliasInput = TargetAliasInput;
declare const tools_TargetAliasInputSchema: typeof TargetAliasInputSchema;
type tools_TargetAliasOutput = TargetAliasOutput;
declare const tools_TargetAliasOutputSchema: typeof TargetAliasOutputSchema;
declare const tools_TargetIdSchema: typeof TargetIdSchema;
type tools_TermInput = TermInput;
declare const tools_TermInputSchema: typeof TermInputSchema;
type tools_TermOutput = TermOutput;
declare const tools_TermOutputSchema: typeof TermOutputSchema;
type tools_UserListInput = UserListInput;
declare const tools_UserListInputSchema: typeof UserListInputSchema;
type tools_UserListOutput = UserListOutput;
declare const tools_UserListOutputSchema: typeof UserListOutputSchema;
type tools_UserSessionListInput = UserSessionListInput;
declare const tools_UserSessionListInputSchema: typeof UserSessionListInputSchema;
type tools_UserSessionListOutput = UserSessionListOutput;
declare const tools_UserSessionListOutputSchema: typeof UserSessionListOutputSchema;
type tools_UserWriteInput = UserWriteInput;
declare const tools_UserWriteInputSchema: typeof UserWriteInputSchema;
type tools_UserWriteOutput = UserWriteOutput;
declare const tools_UserWriteOutputSchema: typeof UserWriteOutputSchema;
declare const tools_WP_CLI_OUTPUT_CAP_DEFAULT: typeof WP_CLI_OUTPUT_CAP_DEFAULT;
type tools_WooReadInput = WooReadInput;
declare const tools_WooReadInputSchema: typeof WooReadInputSchema;
type tools_WooReadOutput = WooReadOutput;
declare const tools_WooReadOutputSchema: typeof WooReadOutputSchema;
type tools_WooWriteInput = WooWriteInput;
declare const tools_WooWriteInputSchema: typeof WooWriteInputSchema;
type tools_WooWriteOutput = WooWriteOutput;
declare const tools_WooWriteOutputSchema: typeof WooWriteOutputSchema;
type tools_WpBuilderDetectInput = WpBuilderDetectInput;
declare const tools_WpBuilderDetectInputSchema: typeof WpBuilderDetectInputSchema;
type tools_WpBuilderDetectOutput = WpBuilderDetectOutput;
declare const tools_WpBuilderDetectOutputSchema: typeof WpBuilderDetectOutputSchema;
type tools_WpCliRunInput = WpCliRunInput;
declare const tools_WpCliRunInputSchema: typeof WpCliRunInputSchema;
type tools_WpCliRunOutput = WpCliRunOutput;
declare const tools_WpCliRunOutputSchema: typeof WpCliRunOutputSchema;
type tools_WpCustomInitInput = WpCustomInitInput;
declare const tools_WpCustomInitInputSchema: typeof WpCustomInitInputSchema;
type tools_WpCustomInitOutput = WpCustomInitOutput;
declare const tools_WpCustomInitOutputSchema: typeof WpCustomInitOutputSchema;
type tools_WpCustomTaskListInput = WpCustomTaskListInput;
declare const tools_WpCustomTaskListInputSchema: typeof WpCustomTaskListInputSchema;
type tools_WpCustomTaskListOutput = WpCustomTaskListOutput;
declare const tools_WpCustomTaskListOutputSchema: typeof WpCustomTaskListOutputSchema;
type tools_WpCustomTaskRemoveInput = WpCustomTaskRemoveInput;
declare const tools_WpCustomTaskRemoveInputSchema: typeof WpCustomTaskRemoveInputSchema;
type tools_WpCustomTaskRemoveOutput = WpCustomTaskRemoveOutput;
declare const tools_WpCustomTaskRemoveOutputSchema: typeof WpCustomTaskRemoveOutputSchema;
type tools_WpCustomTaskScaffoldInput = WpCustomTaskScaffoldInput;
declare const tools_WpCustomTaskScaffoldInputSchema: typeof WpCustomTaskScaffoldInputSchema;
type tools_WpCustomTaskScaffoldOutput = WpCustomTaskScaffoldOutput;
declare const tools_WpCustomTaskScaffoldOutputSchema: typeof WpCustomTaskScaffoldOutputSchema;
type tools_WpCustomTaskToggleInput = WpCustomTaskToggleInput;
declare const tools_WpCustomTaskToggleInputSchema: typeof WpCustomTaskToggleInputSchema;
type tools_WpCustomTaskToggleOutput = WpCustomTaskToggleOutput;
declare const tools_WpCustomTaskToggleOutputSchema: typeof WpCustomTaskToggleOutputSchema;
type tools_WpCustomTaskUpdateInput = WpCustomTaskUpdateInput;
declare const tools_WpCustomTaskUpdateInputSchema: typeof WpCustomTaskUpdateInputSchema;
type tools_WpCustomTaskUpdateOutput = WpCustomTaskUpdateOutput;
declare const tools_WpCustomTaskUpdateOutputSchema: typeof WpCustomTaskUpdateOutputSchema;
type tools_WpDirEnsureInput = WpDirEnsureInput;
declare const tools_WpDirEnsureInputSchema: typeof WpDirEnsureInputSchema;
type tools_WpDirEnsureOutput = WpDirEnsureOutput;
declare const tools_WpDirEnsureOutputSchema: typeof WpDirEnsureOutputSchema;
type tools_WpElementorHtmlAuditInput = WpElementorHtmlAuditInput;
declare const tools_WpElementorHtmlAuditInputSchema: typeof WpElementorHtmlAuditInputSchema;
type tools_WpElementorHtmlAuditOutput = WpElementorHtmlAuditOutput;
declare const tools_WpElementorHtmlAuditOutputSchema: typeof WpElementorHtmlAuditOutputSchema;
type tools_WpElementorPublishInput = WpElementorPublishInput;
declare const tools_WpElementorPublishInputSchema: typeof WpElementorPublishInputSchema;
type tools_WpElementorPublishOutput = WpElementorPublishOutput;
declare const tools_WpElementorPublishOutputSchema: typeof WpElementorPublishOutputSchema;
type tools_WpElementorRestoreInput = WpElementorRestoreInput;
declare const tools_WpElementorRestoreInputSchema: typeof WpElementorRestoreInputSchema;
type tools_WpElementorRestoreOutput = WpElementorRestoreOutput;
declare const tools_WpElementorRestoreOutputSchema: typeof WpElementorRestoreOutputSchema;
type tools_WpElementorSectionInput = WpElementorSectionInput;
declare const tools_WpElementorSectionInputSchema: typeof WpElementorSectionInputSchema;
type tools_WpElementorSectionOutput = WpElementorSectionOutput;
declare const tools_WpElementorSectionOutputSchema: typeof WpElementorSectionOutputSchema;
type tools_WpElementorTemplateApplyInput = WpElementorTemplateApplyInput;
declare const tools_WpElementorTemplateApplyInputSchema: typeof WpElementorTemplateApplyInputSchema;
type tools_WpElementorTemplateApplyOutput = WpElementorTemplateApplyOutput;
declare const tools_WpElementorTemplateApplyOutputSchema: typeof WpElementorTemplateApplyOutputSchema;
type tools_WpElementorTemplateExportInput = WpElementorTemplateExportInput;
declare const tools_WpElementorTemplateExportInputSchema: typeof WpElementorTemplateExportInputSchema;
type tools_WpElementorTemplateExportOutput = WpElementorTemplateExportOutput;
declare const tools_WpElementorTemplateExportOutputSchema: typeof WpElementorTemplateExportOutputSchema;
type tools_WpElementorValidateDataInput = WpElementorValidateDataInput;
declare const tools_WpElementorValidateDataInputSchema: typeof WpElementorValidateDataInputSchema;
type tools_WpElementorValidateDataOutput = WpElementorValidateDataOutput;
declare const tools_WpElementorValidateDataOutputSchema: typeof WpElementorValidateDataOutputSchema;
type tools_WpElementorWidgetAttributeInput = WpElementorWidgetAttributeInput;
declare const tools_WpElementorWidgetAttributeInputSchema: typeof WpElementorWidgetAttributeInputSchema;
type tools_WpElementorWidgetAttributeOutput = WpElementorWidgetAttributeOutput;
declare const tools_WpElementorWidgetAttributeOutputSchema: typeof WpElementorWidgetAttributeOutputSchema;
type tools_WpElementorWidgetSchemaInput = WpElementorWidgetSchemaInput;
declare const tools_WpElementorWidgetSchemaInputSchema: typeof WpElementorWidgetSchemaInputSchema;
type tools_WpElementorWidgetSchemaOutput = WpElementorWidgetSchemaOutput;
declare const tools_WpElementorWidgetSchemaOutputSchema: typeof WpElementorWidgetSchemaOutputSchema;
type tools_WpFileCopyInput = WpFileCopyInput;
declare const tools_WpFileCopyInputSchema: typeof WpFileCopyInputSchema;
type tools_WpFileCopyOutput = WpFileCopyOutput;
declare const tools_WpFileCopyOutputSchema: typeof WpFileCopyOutputSchema;
type tools_WpFileListInput = WpFileListInput;
declare const tools_WpFileListInputSchema: typeof WpFileListInputSchema;
type tools_WpFileListOutput = WpFileListOutput;
declare const tools_WpFileListOutputSchema: typeof WpFileListOutputSchema;
type tools_WpFileReadInput = WpFileReadInput;
declare const tools_WpFileReadInputSchema: typeof WpFileReadInputSchema;
type tools_WpFileReadOutput = WpFileReadOutput;
declare const tools_WpFileReadOutputSchema: typeof WpFileReadOutputSchema;
type tools_WpFileWriteBatchInput = WpFileWriteBatchInput;
declare const tools_WpFileWriteBatchInputSchema: typeof WpFileWriteBatchInputSchema;
type tools_WpFileWriteBatchOutput = WpFileWriteBatchOutput;
declare const tools_WpFileWriteBatchOutputSchema: typeof WpFileWriteBatchOutputSchema;
type tools_WpFileWriteInput = WpFileWriteInput;
declare const tools_WpFileWriteInputSchema: typeof WpFileWriteInputSchema;
type tools_WpFileWriteOutput = WpFileWriteOutput;
declare const tools_WpFileWriteOutputSchema: typeof WpFileWriteOutputSchema;
type tools_WpHealthCheckInput = WpHealthCheckInput;
declare const tools_WpHealthCheckInputSchema: typeof WpHealthCheckInputSchema;
type tools_WpHealthCheckOutput = WpHealthCheckOutput;
declare const tools_WpHealthCheckOutputSchema: typeof WpHealthCheckOutputSchema;
type tools_WpJobCreateInput = WpJobCreateInput;
declare const tools_WpJobCreateInputSchema: typeof WpJobCreateInputSchema;
type tools_WpJobCreateOutput = WpJobCreateOutput;
declare const tools_WpJobCreateOutputSchema: typeof WpJobCreateOutputSchema;
type tools_WpJobStatusInput = WpJobStatusInput;
declare const tools_WpJobStatusInputSchema: typeof WpJobStatusInputSchema;
type tools_WpJobStatusOutput = WpJobStatusOutput;
declare const tools_WpJobStatusOutputSchema: typeof WpJobStatusOutputSchema;
type tools_WpMediaOptimizeInput = WpMediaOptimizeInput;
declare const tools_WpMediaOptimizeInputSchema: typeof WpMediaOptimizeInputSchema;
type tools_WpMediaOptimizeOutput = WpMediaOptimizeOutput;
declare const tools_WpMediaOptimizeOutputSchema: typeof WpMediaOptimizeOutputSchema;
type tools_WpMediaUploadInput = WpMediaUploadInput;
declare const tools_WpMediaUploadInputSchema: typeof WpMediaUploadInputSchema;
type tools_WpMediaUploadOutput = WpMediaUploadOutput;
declare const tools_WpMediaUploadOutputSchema: typeof WpMediaUploadOutputSchema;
type tools_WpRenderGetInput = WpRenderGetInput;
declare const tools_WpRenderGetInputSchema: typeof WpRenderGetInputSchema;
type tools_WpRenderGetOutput = WpRenderGetOutput;
declare const tools_WpRenderGetOutputSchema: typeof WpRenderGetOutputSchema;
type tools_WpSiteBackupInput = WpSiteBackupInput;
declare const tools_WpSiteBackupInputSchema: typeof WpSiteBackupInputSchema;
type tools_WpSiteBackupOutput = WpSiteBackupOutput;
declare const tools_WpSiteBackupOutputSchema: typeof WpSiteBackupOutputSchema;
type tools_WpSiteRestoreInput = WpSiteRestoreInput;
declare const tools_WpSiteRestoreInputSchema: typeof WpSiteRestoreInputSchema;
type tools_WpSiteRestoreOutput = WpSiteRestoreOutput;
declare const tools_WpSiteRestoreOutputSchema: typeof WpSiteRestoreOutputSchema;
type tools_WpmlReadInput = WpmlReadInput;
declare const tools_WpmlReadInputSchema: typeof WpmlReadInputSchema;
type tools_WpmlReadOutput = WpmlReadOutput;
declare const tools_WpmlReadOutputSchema: typeof WpmlReadOutputSchema;
type tools_WpmlWriteInput = WpmlWriteInput;
declare const tools_WpmlWriteInputSchema: typeof WpmlWriteInputSchema;
type tools_WpmlWriteOutput = WpmlWriteOutput;
declare const tools_WpmlWriteOutputSchema: typeof WpmlWriteOutputSchema;
type tools_YoastReadInput = YoastReadInput;
declare const tools_YoastReadInputSchema: typeof YoastReadInputSchema;
type tools_YoastReadOutput = YoastReadOutput;
declare const tools_YoastReadOutputSchema: typeof YoastReadOutputSchema;
type tools_YoastWriteInput = YoastWriteInput;
declare const tools_YoastWriteInputSchema: typeof YoastWriteInputSchema;
type tools_YoastWriteOutput = YoastWriteOutput;
declare const tools_YoastWriteOutputSchema: typeof YoastWriteOutputSchema;
declare namespace tools {
  export { type tools_AcfReadInput as AcfReadInput, tools_AcfReadInputSchema as AcfReadInputSchema, type tools_AcfReadOutput as AcfReadOutput, tools_AcfReadOutputSchema as AcfReadOutputSchema, type tools_AcfWriteInput as AcfWriteInput, tools_AcfWriteInputSchema as AcfWriteInputSchema, type tools_AcfWriteOutput as AcfWriteOutput, tools_AcfWriteOutputSchema as AcfWriteOutputSchema, type tools_AuditManyInput as AuditManyInput, tools_AuditManyInputSchema as AuditManyInputSchema, type tools_AuditManyOutput as AuditManyOutput, tools_AuditManyOutputSchema as AuditManyOutputSchema, type tools_AuditSecurityInput as AuditSecurityInput, tools_AuditSecurityInputSchema as AuditSecurityInputSchema, type tools_AuditSecurityOutput as AuditSecurityOutput, tools_AuditSecurityOutputSchema as AuditSecurityOutputSchema, type tools_BackupCreateInput as BackupCreateInput, tools_BackupCreateInputSchema as BackupCreateInputSchema, type tools_BackupCreateOutput as BackupCreateOutput, tools_BackupCreateOutputSchema as BackupCreateOutputSchema, type tools_BackupRestoreInput as BackupRestoreInput, tools_BackupRestoreInputSchema as BackupRestoreInputSchema, type tools_BackupRestoreOutput as BackupRestoreOutput, tools_BackupRestoreOutputSchema as BackupRestoreOutputSchema, type tools_BricksReadInput as BricksReadInput, tools_BricksReadInputSchema as BricksReadInputSchema, type tools_BricksReadOutput as BricksReadOutput, tools_BricksReadOutputSchema as BricksReadOutputSchema, type tools_BricksWriteInput as BricksWriteInput, tools_BricksWriteInputSchema as BricksWriteInputSchema, type tools_BricksWriteOutput as BricksWriteOutput, tools_BricksWriteOutputSchema as BricksWriteOutputSchema, type tools_CacheToolInput as CacheToolInput, tools_CacheToolInputSchema as CacheToolInputSchema, type tools_CacheToolOutput as CacheToolOutput, tools_CacheToolOutputSchema as CacheToolOutputSchema, type tools_CloneInput as CloneInput, tools_CloneInputSchema as CloneInputSchema, type tools_CloneOutput as CloneOutput, tools_CloneOutputSchema as CloneOutputSchema, type tools_CommentInput as CommentInput, tools_CommentInputSchema as CommentInputSchema, type tools_CommentOutput as CommentOutput, tools_CommentOutputSchema as CommentOutputSchema, type tools_ConnectDockerInput as ConnectDockerInput, tools_ConnectDockerInputSchema as ConnectDockerInputSchema, type tools_ConnectDockerOutput as ConnectDockerOutput, tools_ConnectDockerOutputSchema as ConnectDockerOutputSchema, type tools_ConnectLocalInput as ConnectLocalInput, tools_ConnectLocalInputSchema as ConnectLocalInputSchema, type tools_ConnectLocalOutput as ConnectLocalOutput, tools_ConnectLocalOutputSchema as ConnectLocalOutputSchema, type tools_ConnectRestInput as ConnectRestInput, tools_ConnectRestInputSchema as ConnectRestInputSchema, type tools_ConnectRestOutput as ConnectRestOutput, tools_ConnectRestOutputSchema as ConnectRestOutputSchema, type tools_ConnectSshInput as ConnectSshInput, tools_ConnectSshInputSchema as ConnectSshInputSchema, type tools_ConnectSshOutput as ConnectSshOutput, tools_ConnectSshOutputSchema as ConnectSshOutputSchema, type tools_CptScaffoldInput as CptScaffoldInput, tools_CptScaffoldInputSchema as CptScaffoldInputSchema, type tools_CptScaffoldOutput as CptScaffoldOutput, tools_CptScaffoldOutputSchema as CptScaffoldOutputSchema, type tools_CronToolInput as CronToolInput, tools_CronToolInputSchema as CronToolInputSchema, type tools_CronToolOutput as CronToolOutput, tools_CronToolOutputSchema as CronToolOutputSchema, type tools_DbQueryInput as DbQueryInput, tools_DbQueryInputSchema as DbQueryInputSchema, type tools_DbQueryOutput as DbQueryOutput, tools_DbQueryOutputSchema as DbQueryOutputSchema, type tools_DiagnoseInput as DiagnoseInput, tools_DiagnoseInputSchema as DiagnoseInputSchema, type tools_DiagnoseOutput as DiagnoseOutput, tools_DiagnoseOutputSchema as DiagnoseOutputSchema, type tools_DisconnectInput as DisconnectInput, tools_DisconnectInputSchema as DisconnectInputSchema, type tools_DisconnectOutput as DisconnectOutput, tools_DisconnectOutputSchema as DisconnectOutputSchema, type tools_DiviReadInput as DiviReadInput, tools_DiviReadInputSchema as DiviReadInputSchema, type tools_DiviReadOutput as DiviReadOutput, tools_DiviReadOutputSchema as DiviReadOutputSchema, type tools_DiviWriteInput as DiviWriteInput, tools_DiviWriteInputSchema as DiviWriteInputSchema, type tools_DiviWriteOutput as DiviWriteOutput, tools_DiviWriteOutputSchema as DiviWriteOutputSchema, type tools_ElementorReadInput as ElementorReadInput, tools_ElementorReadInputSchema as ElementorReadInputSchema, type tools_ElementorReadOutput as ElementorReadOutput, tools_ElementorReadOutputSchema as ElementorReadOutputSchema, type tools_ElementorWriteInput as ElementorWriteInput, tools_ElementorWriteInputSchema as ElementorWriteInputSchema, type tools_ElementorWriteOutput as ElementorWriteOutput, tools_ElementorWriteOutputSchema as ElementorWriteOutputSchema, type tools_ExecutePhpInput as ExecutePhpInput, tools_ExecutePhpInputSchema as ExecutePhpInputSchema, type tools_ExecutePhpOutput as ExecutePhpOutput, tools_ExecutePhpOutputSchema as ExecutePhpOutputSchema, type tools_FormsReadInput as FormsReadInput, tools_FormsReadInputSchema as FormsReadInputSchema, type tools_FormsReadOutput as FormsReadOutput, tools_FormsReadOutputSchema as FormsReadOutputSchema, type tools_FormsWriteInput as FormsWriteInput, tools_FormsWriteInputSchema as FormsWriteInputSchema, type tools_FormsWriteOutput as FormsWriteOutput, tools_FormsWriteOutputSchema as FormsWriteOutputSchema, type tools_HookStateInput as HookStateInput, tools_HookStateInputSchema as HookStateInputSchema, type tools_HookStateOutput as HookStateOutput, tools_HookStateOutputSchema as HookStateOutputSchema, type tools_HtaccessEditInput as HtaccessEditInput, tools_HtaccessEditInputSchema as HtaccessEditInputSchema, type tools_HtaccessEditOutput as HtaccessEditOutput, tools_HtaccessEditOutputSchema as HtaccessEditOutputSchema, type tools_IntrospectInput as IntrospectInput, tools_IntrospectInputSchema as IntrospectInputSchema, type tools_IntrospectOutput as IntrospectOutput, tools_IntrospectOutputSchema as IntrospectOutputSchema, type tools_MailTestInput as MailTestInput, tools_MailTestInputSchema as MailTestInputSchema, type tools_MailTestOutput as MailTestOutput, tools_MailTestOutputSchema as MailTestOutputSchema, type tools_MaintenanceUpdateInput as MaintenanceUpdateInput, tools_MaintenanceUpdateInputSchema as MaintenanceUpdateInputSchema, type tools_MaintenanceUpdateOutput as MaintenanceUpdateOutput, tools_MaintenanceUpdateOutputSchema as MaintenanceUpdateOutputSchema, type tools_MemoryListInput as MemoryListInput, tools_MemoryListInputSchema as MemoryListInputSchema, type tools_MemoryListOutput as MemoryListOutput, tools_MemoryListOutputSchema as MemoryListOutputSchema, type tools_MemoryNoteInput as MemoryNoteInput, tools_MemoryNoteInputSchema as MemoryNoteInputSchema, type tools_MemoryNoteOutput as MemoryNoteOutput, tools_MemoryNoteOutputSchema as MemoryNoteOutputSchema, type tools_MemoryRecallInput as MemoryRecallInput, tools_MemoryRecallInputSchema as MemoryRecallInputSchema, type tools_MemoryRecallOutput as MemoryRecallOutput, tools_MemoryRecallOutputSchema as MemoryRecallOutputSchema, type tools_MigrateDataInput as MigrateDataInput, tools_MigrateDataInputSchema as MigrateDataInputSchema, type tools_MigrateDataOutput as MigrateDataOutput, tools_MigrateDataOutputSchema as MigrateDataOutputSchema, type tools_MigrateDryrunInput as MigrateDryrunInput, tools_MigrateDryrunInputSchema as MigrateDryrunInputSchema, type tools_MigrateDryrunOutput as MigrateDryrunOutput, tools_MigrateDryrunOutputSchema as MigrateDryrunOutputSchema, type tools_MigrateSiteInput as MigrateSiteInput, tools_MigrateSiteInputSchema as MigrateSiteInputSchema, type tools_MigrateSiteOutput as MigrateSiteOutput, tools_MigrateSiteOutputSchema as MigrateSiteOutputSchema, type tools_OptionGetInput as OptionGetInput, tools_OptionGetInputSchema as OptionGetInputSchema, type tools_OptionGetOutput as OptionGetOutput, tools_OptionGetOutputSchema as OptionGetOutputSchema, type tools_OptionSetInput as OptionSetInput, tools_OptionSetInputSchema as OptionSetInputSchema, type tools_OptionSetOutput as OptionSetOutput, tools_OptionSetOutputSchema as OptionSetOutputSchema, type tools_OxygenReadInput as OxygenReadInput, tools_OxygenReadInputSchema as OxygenReadInputSchema, type tools_OxygenReadOutput as OxygenReadOutput, tools_OxygenReadOutputSchema as OxygenReadOutputSchema, type tools_OxygenWriteInput as OxygenWriteInput, tools_OxygenWriteInputSchema as OxygenWriteInputSchema, type tools_OxygenWriteOutput as OxygenWriteOutput, tools_OxygenWriteOutputSchema as OxygenWriteOutputSchema, type tools_PairInput as PairInput, tools_PairInputSchema as PairInputSchema, type tools_PairOutput as PairOutput, tools_PairOutputSchema as PairOutputSchema, type tools_PostCreateInput as PostCreateInput, tools_PostCreateInputSchema as PostCreateInputSchema, type tools_PostCreateOutput as PostCreateOutput, tools_PostCreateOutputSchema as PostCreateOutputSchema, type tools_PostGetInput as PostGetInput, tools_PostGetInputSchema as PostGetInputSchema, type tools_PostGetOutput as PostGetOutput, tools_PostGetOutputSchema as PostGetOutputSchema, type tools_PostListInput as PostListInput, tools_PostListInputSchema as PostListInputSchema, type tools_PostListOutput as PostListOutput, tools_PostListOutputSchema as PostListOutputSchema, type tools_PostUpdateInput as PostUpdateInput, tools_PostUpdateInputSchema as PostUpdateInputSchema, type tools_PostUpdateOutput as PostUpdateOutput, tools_PostUpdateOutputSchema as PostUpdateOutputSchema, tools_ProdGuardStatusSchema as ProdGuardStatusSchema, type tools_RankMathReadInput as RankMathReadInput, tools_RankMathReadInputSchema as RankMathReadInputSchema, type tools_RankMathReadOutput as RankMathReadOutput, tools_RankMathReadOutputSchema as RankMathReadOutputSchema, type tools_RankMathWriteInput as RankMathWriteInput, tools_RankMathWriteInputSchema as RankMathWriteInputSchema, type tools_RankMathWriteOutput as RankMathWriteOutput, tools_RankMathWriteOutputSchema as RankMathWriteOutputSchema, type tools_RedirectSetInput as RedirectSetInput, tools_RedirectSetInputSchema as RedirectSetInputSchema, type tools_RedirectSetOutput as RedirectSetOutput, tools_RedirectSetOutputSchema as RedirectSetOutputSchema, type tools_RestDumpInput as RestDumpInput, tools_RestDumpInputSchema as RestDumpInputSchema, type tools_RestDumpOutput as RestDumpOutput, tools_RestDumpOutputSchema as RestDumpOutputSchema, type tools_RestRequestInput as RestRequestInput, tools_RestRequestInputSchema as RestRequestInputSchema, type tools_RestRequestOutput as RestRequestOutput, tools_RestRequestOutputSchema as RestRequestOutputSchema, tools_RunIdSchema as RunIdSchema, type tools_ScaffoldBlockInput as ScaffoldBlockInput, tools_ScaffoldBlockInputSchema as ScaffoldBlockInputSchema, type tools_ScaffoldBlockOutput as ScaffoldBlockOutput, tools_ScaffoldBlockOutputSchema as ScaffoldBlockOutputSchema, type tools_ScaffoldPatternInput as ScaffoldPatternInput, tools_ScaffoldPatternInputSchema as ScaffoldPatternInputSchema, type tools_ScaffoldPatternOutput as ScaffoldPatternOutput, tools_ScaffoldPatternOutputSchema as ScaffoldPatternOutputSchema, type tools_ScaffoldPluginInput as ScaffoldPluginInput, tools_ScaffoldPluginInputSchema as ScaffoldPluginInputSchema, type tools_ScaffoldPluginOutput as ScaffoldPluginOutput, tools_ScaffoldPluginOutputSchema as ScaffoldPluginOutputSchema, type tools_ScaffoldThemeInput as ScaffoldThemeInput, tools_ScaffoldThemeInputSchema as ScaffoldThemeInputSchema, type tools_ScaffoldThemeOutput as ScaffoldThemeOutput, tools_ScaffoldThemeOutputSchema as ScaffoldThemeOutputSchema, type tools_SkillCatalogInput as SkillCatalogInput, tools_SkillCatalogInputSchema as SkillCatalogInputSchema, type tools_SkillCatalogOutput as SkillCatalogOutput, tools_SkillCatalogOutputSchema as SkillCatalogOutputSchema, type tools_SkillDeleteInput as SkillDeleteInput, tools_SkillDeleteInputSchema as SkillDeleteInputSchema, type tools_SkillDeleteOutput as SkillDeleteOutput, tools_SkillDeleteOutputSchema as SkillDeleteOutputSchema, type tools_SkillEditInput as SkillEditInput, tools_SkillEditInputSchema as SkillEditInputSchema, type tools_SkillEditOutput as SkillEditOutput, tools_SkillEditOutputSchema as SkillEditOutputSchema, type tools_SkillGetInput as SkillGetInput, tools_SkillGetInputSchema as SkillGetInputSchema, type tools_SkillGetOutput as SkillGetOutput, tools_SkillGetOutputSchema as SkillGetOutputSchema, type tools_SkillWriteInput as SkillWriteInput, tools_SkillWriteInputSchema as SkillWriteInputSchema, type tools_SkillWriteOutput as SkillWriteOutput, tools_SkillWriteOutputSchema as SkillWriteOutputSchema, type tools_TargetAliasInput as TargetAliasInput, tools_TargetAliasInputSchema as TargetAliasInputSchema, type tools_TargetAliasOutput as TargetAliasOutput, tools_TargetAliasOutputSchema as TargetAliasOutputSchema, tools_TargetIdSchema as TargetIdSchema, type tools_TermInput as TermInput, tools_TermInputSchema as TermInputSchema, type tools_TermOutput as TermOutput, tools_TermOutputSchema as TermOutputSchema, type tools_UserListInput as UserListInput, tools_UserListInputSchema as UserListInputSchema, type tools_UserListOutput as UserListOutput, tools_UserListOutputSchema as UserListOutputSchema, type tools_UserSessionListInput as UserSessionListInput, tools_UserSessionListInputSchema as UserSessionListInputSchema, type tools_UserSessionListOutput as UserSessionListOutput, tools_UserSessionListOutputSchema as UserSessionListOutputSchema, type tools_UserWriteInput as UserWriteInput, tools_UserWriteInputSchema as UserWriteInputSchema, type tools_UserWriteOutput as UserWriteOutput, tools_UserWriteOutputSchema as UserWriteOutputSchema, tools_WP_CLI_OUTPUT_CAP_DEFAULT as WP_CLI_OUTPUT_CAP_DEFAULT, type tools_WooReadInput as WooReadInput, tools_WooReadInputSchema as WooReadInputSchema, type tools_WooReadOutput as WooReadOutput, tools_WooReadOutputSchema as WooReadOutputSchema, type tools_WooWriteInput as WooWriteInput, tools_WooWriteInputSchema as WooWriteInputSchema, type tools_WooWriteOutput as WooWriteOutput, tools_WooWriteOutputSchema as WooWriteOutputSchema, type tools_WpBuilderDetectInput as WpBuilderDetectInput, tools_WpBuilderDetectInputSchema as WpBuilderDetectInputSchema, type tools_WpBuilderDetectOutput as WpBuilderDetectOutput, tools_WpBuilderDetectOutputSchema as WpBuilderDetectOutputSchema, type tools_WpCliRunInput as WpCliRunInput, tools_WpCliRunInputSchema as WpCliRunInputSchema, type tools_WpCliRunOutput as WpCliRunOutput, tools_WpCliRunOutputSchema as WpCliRunOutputSchema, type tools_WpCustomInitInput as WpCustomInitInput, tools_WpCustomInitInputSchema as WpCustomInitInputSchema, type tools_WpCustomInitOutput as WpCustomInitOutput, tools_WpCustomInitOutputSchema as WpCustomInitOutputSchema, type tools_WpCustomTaskListInput as WpCustomTaskListInput, tools_WpCustomTaskListInputSchema as WpCustomTaskListInputSchema, type tools_WpCustomTaskListOutput as WpCustomTaskListOutput, tools_WpCustomTaskListOutputSchema as WpCustomTaskListOutputSchema, type tools_WpCustomTaskRemoveInput as WpCustomTaskRemoveInput, tools_WpCustomTaskRemoveInputSchema as WpCustomTaskRemoveInputSchema, type tools_WpCustomTaskRemoveOutput as WpCustomTaskRemoveOutput, tools_WpCustomTaskRemoveOutputSchema as WpCustomTaskRemoveOutputSchema, type tools_WpCustomTaskScaffoldInput as WpCustomTaskScaffoldInput, tools_WpCustomTaskScaffoldInputSchema as WpCustomTaskScaffoldInputSchema, type tools_WpCustomTaskScaffoldOutput as WpCustomTaskScaffoldOutput, tools_WpCustomTaskScaffoldOutputSchema as WpCustomTaskScaffoldOutputSchema, type tools_WpCustomTaskToggleInput as WpCustomTaskToggleInput, tools_WpCustomTaskToggleInputSchema as WpCustomTaskToggleInputSchema, type tools_WpCustomTaskToggleOutput as WpCustomTaskToggleOutput, tools_WpCustomTaskToggleOutputSchema as WpCustomTaskToggleOutputSchema, type tools_WpCustomTaskUpdateInput as WpCustomTaskUpdateInput, tools_WpCustomTaskUpdateInputSchema as WpCustomTaskUpdateInputSchema, type tools_WpCustomTaskUpdateOutput as WpCustomTaskUpdateOutput, tools_WpCustomTaskUpdateOutputSchema as WpCustomTaskUpdateOutputSchema, type tools_WpDirEnsureInput as WpDirEnsureInput, tools_WpDirEnsureInputSchema as WpDirEnsureInputSchema, type tools_WpDirEnsureOutput as WpDirEnsureOutput, tools_WpDirEnsureOutputSchema as WpDirEnsureOutputSchema, type tools_WpElementorHtmlAuditInput as WpElementorHtmlAuditInput, tools_WpElementorHtmlAuditInputSchema as WpElementorHtmlAuditInputSchema, type tools_WpElementorHtmlAuditOutput as WpElementorHtmlAuditOutput, tools_WpElementorHtmlAuditOutputSchema as WpElementorHtmlAuditOutputSchema, type tools_WpElementorPublishInput as WpElementorPublishInput, tools_WpElementorPublishInputSchema as WpElementorPublishInputSchema, type tools_WpElementorPublishOutput as WpElementorPublishOutput, tools_WpElementorPublishOutputSchema as WpElementorPublishOutputSchema, type tools_WpElementorRestoreInput as WpElementorRestoreInput, tools_WpElementorRestoreInputSchema as WpElementorRestoreInputSchema, type tools_WpElementorRestoreOutput as WpElementorRestoreOutput, tools_WpElementorRestoreOutputSchema as WpElementorRestoreOutputSchema, type tools_WpElementorSectionInput as WpElementorSectionInput, tools_WpElementorSectionInputSchema as WpElementorSectionInputSchema, type tools_WpElementorSectionOutput as WpElementorSectionOutput, tools_WpElementorSectionOutputSchema as WpElementorSectionOutputSchema, type tools_WpElementorTemplateApplyInput as WpElementorTemplateApplyInput, tools_WpElementorTemplateApplyInputSchema as WpElementorTemplateApplyInputSchema, type tools_WpElementorTemplateApplyOutput as WpElementorTemplateApplyOutput, tools_WpElementorTemplateApplyOutputSchema as WpElementorTemplateApplyOutputSchema, type tools_WpElementorTemplateExportInput as WpElementorTemplateExportInput, tools_WpElementorTemplateExportInputSchema as WpElementorTemplateExportInputSchema, type tools_WpElementorTemplateExportOutput as WpElementorTemplateExportOutput, tools_WpElementorTemplateExportOutputSchema as WpElementorTemplateExportOutputSchema, type tools_WpElementorValidateDataInput as WpElementorValidateDataInput, tools_WpElementorValidateDataInputSchema as WpElementorValidateDataInputSchema, type tools_WpElementorValidateDataOutput as WpElementorValidateDataOutput, tools_WpElementorValidateDataOutputSchema as WpElementorValidateDataOutputSchema, type tools_WpElementorWidgetAttributeInput as WpElementorWidgetAttributeInput, tools_WpElementorWidgetAttributeInputSchema as WpElementorWidgetAttributeInputSchema, type tools_WpElementorWidgetAttributeOutput as WpElementorWidgetAttributeOutput, tools_WpElementorWidgetAttributeOutputSchema as WpElementorWidgetAttributeOutputSchema, type tools_WpElementorWidgetSchemaInput as WpElementorWidgetSchemaInput, tools_WpElementorWidgetSchemaInputSchema as WpElementorWidgetSchemaInputSchema, type tools_WpElementorWidgetSchemaOutput as WpElementorWidgetSchemaOutput, tools_WpElementorWidgetSchemaOutputSchema as WpElementorWidgetSchemaOutputSchema, type tools_WpFileCopyInput as WpFileCopyInput, tools_WpFileCopyInputSchema as WpFileCopyInputSchema, type tools_WpFileCopyOutput as WpFileCopyOutput, tools_WpFileCopyOutputSchema as WpFileCopyOutputSchema, type tools_WpFileListInput as WpFileListInput, tools_WpFileListInputSchema as WpFileListInputSchema, type tools_WpFileListOutput as WpFileListOutput, tools_WpFileListOutputSchema as WpFileListOutputSchema, type tools_WpFileReadInput as WpFileReadInput, tools_WpFileReadInputSchema as WpFileReadInputSchema, type tools_WpFileReadOutput as WpFileReadOutput, tools_WpFileReadOutputSchema as WpFileReadOutputSchema, type tools_WpFileWriteBatchInput as WpFileWriteBatchInput, tools_WpFileWriteBatchInputSchema as WpFileWriteBatchInputSchema, type tools_WpFileWriteBatchOutput as WpFileWriteBatchOutput, tools_WpFileWriteBatchOutputSchema as WpFileWriteBatchOutputSchema, type tools_WpFileWriteInput as WpFileWriteInput, tools_WpFileWriteInputSchema as WpFileWriteInputSchema, type tools_WpFileWriteOutput as WpFileWriteOutput, tools_WpFileWriteOutputSchema as WpFileWriteOutputSchema, type tools_WpHealthCheckInput as WpHealthCheckInput, tools_WpHealthCheckInputSchema as WpHealthCheckInputSchema, type tools_WpHealthCheckOutput as WpHealthCheckOutput, tools_WpHealthCheckOutputSchema as WpHealthCheckOutputSchema, type tools_WpJobCreateInput as WpJobCreateInput, tools_WpJobCreateInputSchema as WpJobCreateInputSchema, type tools_WpJobCreateOutput as WpJobCreateOutput, tools_WpJobCreateOutputSchema as WpJobCreateOutputSchema, type tools_WpJobStatusInput as WpJobStatusInput, tools_WpJobStatusInputSchema as WpJobStatusInputSchema, type tools_WpJobStatusOutput as WpJobStatusOutput, tools_WpJobStatusOutputSchema as WpJobStatusOutputSchema, type tools_WpMediaOptimizeInput as WpMediaOptimizeInput, tools_WpMediaOptimizeInputSchema as WpMediaOptimizeInputSchema, type tools_WpMediaOptimizeOutput as WpMediaOptimizeOutput, tools_WpMediaOptimizeOutputSchema as WpMediaOptimizeOutputSchema, type tools_WpMediaUploadInput as WpMediaUploadInput, tools_WpMediaUploadInputSchema as WpMediaUploadInputSchema, type tools_WpMediaUploadOutput as WpMediaUploadOutput, tools_WpMediaUploadOutputSchema as WpMediaUploadOutputSchema, type tools_WpRenderGetInput as WpRenderGetInput, tools_WpRenderGetInputSchema as WpRenderGetInputSchema, type tools_WpRenderGetOutput as WpRenderGetOutput, tools_WpRenderGetOutputSchema as WpRenderGetOutputSchema, type tools_WpSiteBackupInput as WpSiteBackupInput, tools_WpSiteBackupInputSchema as WpSiteBackupInputSchema, type tools_WpSiteBackupOutput as WpSiteBackupOutput, tools_WpSiteBackupOutputSchema as WpSiteBackupOutputSchema, type tools_WpSiteRestoreInput as WpSiteRestoreInput, tools_WpSiteRestoreInputSchema as WpSiteRestoreInputSchema, type tools_WpSiteRestoreOutput as WpSiteRestoreOutput, tools_WpSiteRestoreOutputSchema as WpSiteRestoreOutputSchema, type tools_WpmlReadInput as WpmlReadInput, tools_WpmlReadInputSchema as WpmlReadInputSchema, type tools_WpmlReadOutput as WpmlReadOutput, tools_WpmlReadOutputSchema as WpmlReadOutputSchema, type tools_WpmlWriteInput as WpmlWriteInput, tools_WpmlWriteInputSchema as WpmlWriteInputSchema, type tools_WpmlWriteOutput as WpmlWriteOutput, tools_WpmlWriteOutputSchema as WpmlWriteOutputSchema, type tools_YoastReadInput as YoastReadInput, tools_YoastReadInputSchema as YoastReadInputSchema, type tools_YoastReadOutput as YoastReadOutput, tools_YoastReadOutputSchema as YoastReadOutputSchema, type tools_YoastWriteInput as YoastWriteInput, tools_YoastWriteInputSchema as YoastWriteInputSchema, type tools_YoastWriteOutput as YoastWriteOutput, tools_YoastWriteOutputSchema as YoastWriteOutputSchema };
}

export { ProdGuard, type Target, TargetRegistry, createServer, errors, loadProfile, openTarget, tools as schema };