@zhama/tego-plugin-sdk 0.0.0-stage → 1.36.1

package/dist/manifest-types-DQARCQJt.d.cts

@@ -0,0 +1,627 @@
+/**
+ * Operator-supplied configuration, declared per part.
+ *
+ * Three sections, never one. A plugin's browser code, its backend process and
+ * its claw extension are three different audiences, and folding their settings
+ * into a single object makes "does the frontend get to see this API key" a
+ * question answered by remembering to strip a field before responding. Split,
+ * the frontend simply has no path to the other two.
+ *
+ * The frontend and backend sections are declared here, in `tego.plugin.json`.
+ * The claw section is not: `claw/openclaw.plugin.json` already carries a
+ * `configSchema`, claw itself validates against it, and a second declaration
+ * would be a second truth about the same fields.
+ *
+ * ## Why the schema subset is this narrow
+ *
+ * A flat object of scalars, string enums and string arrays. Two reasons, and
+ * the second is the load-bearing one:
+ *
+ * - The form has to render without an author previewing it. Anything the
+ *   renderer would fall back to a JSON textarea for is a field the operator
+ *   fills by typing JSON, which is not a form.
+ * - Per-avatar claw overrides merge at top-level key granularity, on purpose:
+ *   deep-merging nested objects and arrays has no single obvious semantics.
+ *   A nested object would therefore be replaced wholesale by an override,
+ *   which is not what its shape suggests. Refusing nesting keeps the storage
+ *   model and the declaration honest with each other.
+ */
+
+/** The three audiences a plugin's settings can belong to. */
+declare const PLUGIN_CONFIG_SECTIONS: readonly ["frontend", "backend", "claw"];
+type PluginConfigSection = (typeof PLUGIN_CONFIG_SECTIONS)[number];
+/**
+ * Stands in for a stored secret whenever a value leaves the server towards a
+ * human.
+ *
+ * The same string claw uses, deliberately: a secret that survived a round trip
+ * through one console and got clobbered by the other would be the worst
+ * possible outcome of having two sentinels. Writing it back means "leave the
+ * stored value alone".
+ */
+declare const PLUGIN_CONFIG_SECRET_SENTINEL = "__OPENCLAW_REDACTED__";
+type PluginConfigFieldType = 'string' | 'number' | 'integer' | 'boolean' | 'array';
+/** One field. Flat by construction — no `properties`, no `$ref`, no unions. */
+interface PluginConfigFieldSchema {
+    type: PluginConfigFieldType;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    /** Closed set of allowed values. Strings and numbers only. */
+    enum?: (string | number)[];
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'uri' | 'email';
+    minimum?: number;
+    maximum?: number;
+    /** Required for `type: "array"`, and only a string element is supported. */
+    items?: {
+        type: 'string';
+        enum?: string[];
+    };
+    maxItems?: number;
+}
+interface PluginConfigSchema {
+    type: 'object';
+    properties: Record<string, PluginConfigFieldSchema>;
+    required?: string[];
+    /** Always false: an operator cannot invent a key the plugin never reads. */
+    additionalProperties?: false;
+}
+/**
+ * How one field is presented.
+ *
+ * `label` and `help` are {@link LocalizedText} because the platform ships ten
+ * languages and a plugin's settings screen has no reason to be the one part of
+ * it that is English-only. A plain string still works and means "the same in
+ * every language", which is right for a field named after a protocol.
+ */
+interface PluginConfigUiHint {
+    label?: LocalizedText;
+    help?: LocalizedText;
+    placeholder?: LocalizedText;
+    order?: number;
+    /** Collapsed by default. For knobs with a sane default nobody should touch. */
+    advanced?: boolean;
+    /**
+     * Stored encrypted, never returned in plaintext, never placed in the
+     * container environment.
+     *
+     * Illegal in the frontend section: that section is delivered to the browser
+     * in full, so a secret there is public by construction. Validation rejects
+     * it rather than quietly stripping the flag.
+     */
+    sensitive?: boolean;
+}
+interface PluginConfigDeclaration {
+    schema: PluginConfigSchema;
+    uiHints?: Record<string, PluginConfigUiHint>;
+}
+/** What the install screen says about one section, without opening a schema. */
+interface PluginConfigSectionSummary {
+    fieldCount: number;
+    /** Property names the section cannot run without. */
+    required: string[];
+    /** Property names stored encrypted. */
+    sensitive: string[];
+}
+declare const EMPTY_CONFIG_SECTION_SUMMARY: PluginConfigSectionSummary;
+declare function summarizeConfigDeclaration(declaration: PluginConfigDeclaration | undefined): PluginConfigSectionSummary;
+/**
+ * The same summary for the claw section, read out of an OpenClaw manifest.
+ *
+ * Separate because that schema is not held to the subset above — claw owns it,
+ * and holding an already-valid OpenClaw extension to a Tego-only restriction
+ * would refuse packages claw itself runs. Anything nested is counted at the
+ * top level and rendered by the form's own fallback.
+ */
+declare function summarizeClawConfig(clawManifest: Record<string, unknown> | null): PluginConfigSectionSummary;
+/**
+ * Replace every stored secret with the sentinel.
+ *
+ * Applied on the way out to any human-facing surface. Keys absent from the
+ * stored value stay absent — writing a sentinel for a secret nobody has set
+ * would make the form show a filled field the operator cannot clear.
+ */
+declare function redactSecrets(value: Record<string, unknown>, sensitive: readonly string[]): Record<string, unknown>;
+/**
+ * Put the stored secret back wherever the submitted value is the sentinel.
+ *
+ * The inverse of {@link redactSecrets}, and the reason a form can be saved
+ * without the operator retyping every key it never showed them.
+ *
+ * A sentinel with no stored counterpart is dropped rather than saved
+ * literally: it means the form rendered a value that has since been deleted,
+ * and persisting the marker itself would give the plugin a password of
+ * `__OPENCLAW_REDACTED__`.
+ */
+declare function restoreSecrets(submitted: Record<string, unknown>, stored: Record<string, unknown>, sensitive: readonly string[]): Record<string, unknown>;
+/**
+ * Fill in declared defaults for keys the operator left unset.
+ *
+ * `properties` is defaulted although the type requires it: the claw section's
+ * schema is whatever an OpenClaw manifest declares, which this type describes
+ * but does not enforce, and a schema of `{"type":"object"}` would otherwise
+ * throw here rather than simply having no defaults to apply.
+ */
+declare function applyConfigDefaults(schema: PluginConfigSchema, value: Record<string, unknown>): Record<string, unknown>;
+/** A hint's label in one language, falling back to the property name. */
+declare function configFieldLabel(name: string, hint: PluginConfigUiHint | undefined, field: PluginConfigFieldSchema | undefined, locale: string): string;
+
+/**
+ * `tego.plugin.json` — the one manifest every Tego plugin ships.
+ *
+ * A plugin is a single archive containing up to three parts: a frontend module
+ * loaded into the host shell, a backend process the platform runs, and an
+ * OpenClaw extension loaded by claw containers. At least one part is required;
+ * a plugin with only `claw` is exactly what the ecosystem uploads today.
+ *
+ * The claw part keeps its own upstream `openclaw.plugin.json` untouched inside
+ * its subdirectory. This manifest wraps it rather than replacing it, so claw's
+ * loader and this platform never have to agree on a schema.
+ */
+
+/** A display string, either a single value or one per locale tag. */
+type LocalizedText = string | Record<string, string>;
+/**
+ * Icon names a nav entry may choose from.
+ *
+ * A closed list rather than "any `lucide-react` name", because resolving an
+ * arbitrary string to a component means importing the whole icon set into the
+ * shell — which is why every plugin entry used to render the same generic
+ * puzzle piece. A fixed list is a static map the bundler can shake.
+ *
+ * Adding a name is a minor host API bump: older shells would render the
+ * fallback for an icon they have no entry for.
+ */
+declare const PLUGIN_NAV_ICONS: readonly ["bar-chart", "bell", "bookmark", "book-open", "bot", "briefcase", "building", "calendar", "chart-pie", "clipboard-list", "clock", "contact", "credit-card", "database", "file-text", "folder", "globe", "handshake", "inbox", "key", "layers", "layout-dashboard", "library", "link", "list-todo", "mail", "map-pin", "message-square", "mic", "package", "phone", "puzzle", "receipt", "search", "settings", "shield", "shopping-cart", "sliders", "sparkles", "star", "table", "tag", "target", "trending-up", "truck", "users", "wallet", "workflow", "wrench", "zap"];
+type PluginNavIcon = (typeof PLUGIN_NAV_ICONS)[number];
+/** Rendered for an entry that names no icon. */
+declare const PLUGIN_NAV_ICON_FALLBACK: PluginNavIcon;
+/**
+ * One page a frontend part registers.
+ *
+ * These are not sidebar rows. The shell gives a plugin exactly one row —
+ * itself — which opens the plugin at its root; the plugin routes its pages
+ * from there. A plugin with at least one entry gets that row.
+ *
+ * Entries do not gate access. Who may open a plugin follows the AI employees
+ * it is installed on (tenant-scoped plugins are open to the whole tenant),
+ * and the host writes no role menu or permission for them.
+ */
+interface PluginNavEntry {
+    /** Stable identifier within the plugin; what `ctx.can(key)` checks. */
+    key: string;
+    /** i18n key resolved against the plugin's own bundle, not the host's. */
+    labelKey: string;
+    /**
+     * Kept for manifest compatibility; the host does not read it. The sidebar
+     * row's icon is the frontend part's own `icon`.
+     */
+    icon?: PluginNavIcon;
+    /** Kept for manifest compatibility; the host does not read it. */
+    order?: number;
+    /** Subpath under `/p/<pluginId>`. Defaults to the plugin root. */
+    path?: string;
+}
+interface PluginFrontendPart {
+    /** Directory inside the archive. Defaults to `frontend`. */
+    dir?: string;
+    /** SystemJS entry relative to `dir`. Defaults to `index.js`. */
+    entry?: string;
+    /** Locale JSON directory relative to `dir`. Defaults to `i18n`. */
+    i18nDir?: string;
+    /**
+     * The plugin's icon in the shell's sidebar. Defaults to the generic plugin
+     * icon.
+     *
+     * Declared here and not taken from `nav`, because the row stands for the
+     * plugin rather than for any one of its pages: borrowing the first page's
+     * icon would put a dashboard glyph next to "CRM" only because the author
+     * happened to list the dashboard first.
+     */
+    icon?: PluginNavIcon;
+    nav?: PluginNavEntry[];
+    /**
+     * Settings delivered to the browser alongside discovery.
+     *
+     * Public by construction — anything here reaches the page — so a
+     * `sensitive` hint in this section is a validation error rather than a
+     * field that gets quietly stripped.
+     */
+    config?: PluginConfigDeclaration;
+}
+/**
+ * Resource caps for the backend process.
+ *
+ * Only what the orchestrator actually applies. Egress controls used to be
+ * declarable here and were enforced nowhere — a field that reads as a network
+ * policy while every host stays reachable is worse than no field, because it
+ * is the one an operator would rely on.
+ */
+interface PluginBackendLimits {
+    memoryMb?: number;
+    cpuMs?: number;
+    requestTimeoutMs?: number;
+}
+/**
+ * Language runtime of the backend process.
+ *
+ * Each value maps to one platform-owned runner image; a package never ships
+ * its own. See `docs/architecture/plugin-backend-protocol.md`.
+ */
+type PluginBackendRuntime = 'node' | 'python';
+declare const PLUGIN_BACKEND_RUNTIMES: readonly PluginBackendRuntime[];
+type PluginBackendPlatform = 'linux/amd64' | 'linux/arm64';
+declare const PLUGIN_BACKEND_PLATFORMS: readonly PluginBackendPlatform[];
+type PluginPublicRouteMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * One anonymous entry point into the backend.
+ *
+ * `path` is literal segments and `:name` parameters, e.g.
+ * `/public/inspections/:token`. The gateway forwards only requests that match
+ * a declaration; everything else under the public prefix is a 404 that never
+ * reaches the plugin.
+ */
+interface PluginPublicRoute {
+    method: PluginPublicRouteMethod;
+    path: string;
+}
+interface PluginSchemaRepair {
+    id: string;
+    /** SQL generated from an isolated legacy schema, relative to backend dir. */
+    sqlFile: string;
+    table: string;
+    column: string;
+    postgresType: 'integer' | 'text' | 'boolean' | 'bigint' | 'jsonb';
+}
+interface PluginBackendPart {
+    /** Directory inside the archive. Defaults to `backend`. */
+    dir?: string;
+    /** Defaults to `node`. */
+    runtime?: PluginBackendRuntime;
+    /**
+     * Entry relative to `dir`. Defaults to `index.js` for node and `app.py` for
+     * python.
+     */
+    entry?: string;
+    /**
+     * CPU architectures the package's vendored wheels cover. Python only, and
+     * defaults to both: a release that installs on one node pool and not the
+     * other fails at the worst possible moment.
+     */
+    platforms?: PluginBackendPlatform[];
+    /**
+     * Exact outbound targets. A bare hostname means HTTPS 443; hostname:port
+     * and IP:port permit that specific port through the platform egress proxy.
+     * A lone `*` permits every routable target and port, including private IPs.
+     */
+    egress?: string[];
+    /**
+     * Append-only SQL directory relative to `dir`, applied by the host into the
+     * plugin's dedicated schema. Defaults to `migrations`.
+     */
+    migrationsDir?: string;
+    compatibilityRepairs?: PluginSchemaRepair[];
+    /** Readiness path the runtime polls. Defaults to `/healthz`. */
+    healthPath?: string;
+    limits?: PluginBackendLimits;
+    /**
+     * Routes anyone may call without signing in — a QR code scanned on a
+     * phone, a link sent to a contractor. Avatar plugins require a bound and
+     * enabled employee in the public URL (or an existing legacy target).
+     * Each request carries a signed anonymous context; the plugin verifies its token.
+     */
+    publicRoutes?: PluginPublicRoute[];
+    /**
+     * Settings the backend process reads at startup.
+     *
+     * Fetched over the host API rather than injected as environment variables:
+     * env is visible to `docker inspect`, to the orchestrator's API and to crash
+     * dumps, and it is fixed at container creation, so rotating a key would mean
+     * recreating the container.
+     *
+     * A required field with no value leaves the install in `awaiting_config` —
+     * installed, no container, and an explanation instead of a 502.
+     */
+    config?: PluginConfigDeclaration;
+}
+interface PluginClawHooks {
+    allowPromptInjection?: boolean;
+    allowConversationAccess?: boolean;
+}
+interface PluginClawPart {
+    /** Runtime hook access disclosed by the installed package. */
+    hooks?: PluginClawHooks;
+    /** Directory inside the archive holding an intact OpenClaw extension. */
+    dir?: string;
+}
+/**
+ * A static site served to anonymous visitors — the pages behind
+ * `publicRoutes`. Built with its own dependencies, not against the host's
+ * shared modules: nobody signed in means no shell to load into.
+ */
+interface PluginPublicFrontendPart {
+    /** Directory inside the archive holding `index.html`. Defaults to `public-frontend`. */
+    dir?: string;
+}
+interface PluginParts {
+    frontend?: PluginFrontendPart;
+    backend?: PluginBackendPart;
+    claw?: PluginClawPart;
+    publicFrontend?: PluginPublicFrontendPart;
+}
+interface PluginPermissions {
+    required?: string[];
+}
+/**
+ * The plugin's own roles and permissions, enforced by its backend through
+ * `@tego/plugin-sdk/access`.
+ *
+ * `catalog` is a path inside the package, so the same file the backend is
+ * built from is the one upload validates and discloses. Accounts still come
+ * from the host; the catalog only says what they may do inside this plugin.
+ */
+interface PluginAccess {
+    catalog: string;
+}
+/**
+ * Who a plugin belongs to once installed.
+ *
+ * `avatar` — the plugin is a capability of a digital avatar. Install picks
+ * which avatars get it, and its pages are visible while one of those is
+ * active.
+ *
+ * `tenant` — a workspace-wide application with no per-avatar meaning. Visible
+ * to everyone in the tenant who holds the menu permission. A claw part on a
+ * tenant-scoped plugin goes to every avatar in the tenant, including avatars
+ * created later: nobody picks avatars, so nobody can forget the new ones.
+ *
+ * Declared, never inferred. "Has a claw part" happens to correlate today, but
+ * a frontend-only reporting page over the same backend is tenant-scoped, and
+ * guessing wrong means the plugin is either invisible or visible to everyone.
+ */
+type PluginScope = 'avatar' | 'tenant';
+/**
+ * What installing this plugin will bring, shown to the operator before they
+ * confirm.
+ *
+ * These are **disclosures**, not grants. Plugins are first-party and the
+ * frontend runs with the shell's own privileges, so calling them permissions
+ * would promise an isolation boundary that does not exist. `database` is the
+ * exception that also changes behaviour, because provisioning a schema is a
+ * thing the host does or does not do.
+ */
+interface PluginDeclares {
+    /**
+     * The backend gets a dedicated Postgres schema and a role scoped to it, and
+     * the host applies the package's migrations into it.
+     *
+     * Defaults to true when a backend part exists, which is what the platform
+     * has always done. A backend that only proxies or computes sets it false and
+     * then finds `host.db` unavailable.
+     */
+    database?: boolean;
+    /**
+     * The backend stores objects through the host storage API, under a prefix
+     * derived from the install.
+     *
+     * A byte budget is deliberately not declarable: nothing accounts total usage
+     * yet, and a number no one enforces reads as a cap. The per-object ceiling
+     * the host does enforce is a platform constant, not a plugin's choice.
+     */
+    storage?: boolean;
+    /**
+     * The backend publishes `plugin.<id>.*` events to the tenant's subscribers.
+     *
+     * Publish-only. Plugin backends cannot subscribe to platform events.
+     */
+    events?: boolean;
+    /** The backend may send durable, recipient-scoped messages to the host inbox. */
+    notifications?: boolean;
+}
+/**
+ * Business wording for a plugin tool in the audit trail. Without it an auditor
+ * sees `crm_query_customer {"id":"C123"}`; with it, "查询客户 C123 的持仓".
+ */
+interface PluginAuditToolDeclaration {
+    category?: 'read' | 'write' | 'search' | 'browse' | 'exec' | 'knowledge' | 'memory' | 'message' | 'schedule' | 'delegate' | 'document' | 'plugin';
+    /** Template with `{param}` placeholders filled from the call parameters. */
+    title?: LocalizedText;
+    /** Parameter naming the business object, e.g. `customerId`. */
+    target?: string;
+    /** `high` raises a risk flag on every call. */
+    risk?: 'low' | 'medium' | 'high';
+    /** Data classes touched, e.g. `pii`, `account`, `trade`. */
+    dataClasses?: string[];
+}
+interface PluginAuditDeclarations {
+    /** Keyed by the tool name the claw part registers. */
+    tools?: Record<string, PluginAuditToolDeclaration>;
+}
+interface PluginAgentReadinessDeclaration {
+    /** Backend route path (relative to plugin root) returning PluginAgentReadinessResponse. */
+    path: string;
+}
+/**
+ * Text fields are `LocalizedText`: the host picks the viewer's locale, then
+ * `en`. `action.route` is relative to the plugin's own pages (`/deals`), never
+ * an absolute URL.
+ */
+interface PluginAgentReadinessItem {
+    id: string;
+    title: LocalizedText;
+    why?: LocalizedText | undefined;
+    status: 'ready' | 'action_needed' | 'not_applicable' | 'unknown';
+    owner: 'self' | 'other';
+    ownerHint?: LocalizedText | undefined;
+    optional?: boolean | undefined;
+    action?: {
+        label: LocalizedText;
+        route: string;
+    } | undefined;
+}
+interface PluginAgentReadinessResponse {
+    items: PluginAgentReadinessItem[];
+}
+interface PluginWorkDelegationDeclaration {
+    allowedAvatarRoles: string[];
+    /**
+     * @deprecated Host API 1.33 grants and revokes in its own dialog. Still
+     * accepted so older manifests validate; the host no longer links to it.
+     */
+    settingsRoute?: string;
+    /** Host API 1.33: one sentence in the consent dialog, at most 120 characters. */
+    summary?: LocalizedText;
+    /** Host API 1.33: https link shown in the consent dialog. */
+    privacyPolicyUrl?: string;
+    /**
+     * Host API 1.33: the consent dialog offers, unchecked, to also record the
+     * person's new conversations with the employee for this plugin.
+     */
+    conversationCapture?: boolean;
+}
+interface TegoPluginManifest {
+    /** Bumped only when this manifest's own shape breaks. */
+    manifestVersion: 1;
+    /**
+     * Flat identifier. Doubles as a directory name under claw's `extensions/`
+     * and as an `openclaw.json` object key, so scoped npm-style ids are refused.
+     */
+    id: string;
+    version: string;
+    displayName: LocalizedText;
+    description?: LocalizedText;
+    author?: string;
+    homepage?: string;
+    /** Icon path inside the archive. */
+    icon?: string;
+    category?: string;
+    tags?: string[];
+    /**
+     * Caret range of the host API this plugin was built against, e.g. `^1.2.0`.
+     * Required once a frontend or backend part exists, because both bind to host
+     * modules; a claw-only plugin is governed by claw's own `minHostVersion`.
+     */
+    hostApiRange?: string;
+    scope: PluginScope;
+    declares?: PluginDeclares;
+    parts: PluginParts;
+    permissions?: PluginPermissions;
+    /** Host API 1.22: plugin-owned roles and permissions. */
+    access?: PluginAccess;
+    /** How this plugin's tools read in the audit trail. */
+    audit?: PluginAuditDeclarations;
+    /** Employee templates shipped as immutable assets in this plugin release. */
+    agentTemplates?: {
+        key: string;
+        entry: string;
+        icon?: string;
+    }[];
+    /**
+     * Host-enforced eligibility for work delegation. Omit to disable; `*` allows any role.
+     * Requires a backend part. The host owns the consent dialog and the grant
+     * and revoke entries, so a plugin builds no delegation UI of its own.
+     */
+    workDelegation?: PluginWorkDelegationDeclaration;
+    /** Read-only record routes used by the generic conversation binding API. */
+    conversationRecordRoutes?: {
+        entity: string;
+        path: string;
+        contextQuery?: string;
+        labelFields?: string[];
+    }[];
+    /** Per-user business readiness endpoint for digital employees using this plugin. */
+    agentReadiness?: PluginAgentReadinessDeclaration;
+}
+declare const PLUGIN_MANIFEST_FILENAME = "tego.plugin.json";
+/** Mirrors OpenClaw's own manifest filename, found inside the claw part. */
+declare const CLAW_MANIFEST_FILENAME = "openclaw.plugin.json";
+declare const PLUGIN_PART_DEFAULTS: {
+    readonly frontend: {
+        readonly dir: "frontend";
+        readonly entry: "index.js";
+        readonly i18nDir: "i18n";
+    };
+    readonly backend: {
+        readonly dir: "backend";
+        readonly runtime: "node";
+        readonly entry: {
+            readonly node: "index.js";
+            readonly python: "app.py";
+        };
+        readonly migrationsDir: "migrations";
+        readonly healthPath: "/healthz";
+    };
+    readonly claw: {
+        readonly dir: "claw";
+    };
+    readonly publicFrontend: {
+        readonly dir: "public-frontend";
+        readonly entry: "index.html";
+    };
+};
+/**
+ * Scope of a manifest, tolerating one written before the field existed.
+ *
+ * Validation requires `scope` on every upload, so the fallback only ever fires
+ * for a manifest already stored on a release row. It reproduces what those
+ * releases got in practice — a claw part made the plugin an avatar capability,
+ * and nothing else was avatar-scoped.
+ */
+declare function resolvePluginScope(manifest: Pick<TegoPluginManifest, 'parts'> & {
+    scope?: PluginScope;
+}): PluginScope;
+/** Every disclosure with its default applied, so callers never see undefined. */
+declare function resolvePluginDeclares(manifest: Pick<TegoPluginManifest, 'parts' | 'declares'>): Required<PluginDeclares>;
+type PluginPartName = keyof PluginParts;
+declare const PLUGIN_PART_NAMES: readonly PluginPartName[];
+/** Part names this manifest actually declares, in stable order. */
+declare function declaredPartNames(manifest: TegoPluginManifest): PluginPartName[];
+interface ResolvedFrontendPart {
+    dir: string;
+    entryPath: string;
+    i18nDirPath: string;
+    nav: PluginNavEntry[];
+    config?: PluginConfigDeclaration;
+}
+interface ResolvedBackendPart {
+    dir: string;
+    runtime: PluginBackendRuntime;
+    entryPath: string;
+    /** Empty for node, which ships no native dependencies. */
+    platforms: PluginBackendPlatform[];
+    egress: string[];
+    migrationsDirPath: string;
+    compatibilityRepairs?: PluginSchemaRepair[];
+    healthPath: string;
+    limits: PluginBackendLimits;
+    publicRoutes: PluginPublicRoute[];
+    config?: PluginConfigDeclaration;
+}
+interface ResolvedClawPart {
+    hooks?: PluginClawHooks;
+    dir: string;
+    manifestPath: string;
+}
+interface ResolvedPublicFrontendPart {
+    dir: string;
+    entryPath: string;
+}
+interface ResolvedPluginParts {
+    frontend?: ResolvedFrontendPart;
+    backend?: ResolvedBackendPart;
+    claw?: ResolvedClawPart;
+    publicFrontend?: ResolvedPublicFrontendPart;
+}
+/**
+ * Apply every part default once, producing archive-relative paths.
+ *
+ * The only place defaults live. Validation, install and the runtimes all read
+ * this, so a plugin that omits `entry` cannot be resolved differently by two
+ * callers.
+ */
+declare function resolvePluginParts(manifest: TegoPluginManifest): ResolvedPluginParts;
+
+export { resolvePluginParts as $, type PluginConfigDeclaration as A, type PluginConfigFieldSchema as B, CLAW_MANIFEST_FILENAME as C, type PluginConfigFieldType as D, EMPTY_CONFIG_SECTION_SUMMARY as E, type PluginConfigSchema as F, type PluginConfigUiHint as G, type PluginFrontendPart as H, type PluginParts as I, type PluginPermissions as J, type PluginPublicFrontendPart as K, type LocalizedText as L, type PluginPublicRouteMethod as M, type PluginSchemaRepair as N, type PluginWorkDelegationDeclaration as O, type PluginPublicRoute as P, type ResolvedClawPart as Q, type ResolvedBackendPart as R, type ResolvedFrontendPart as S, type TegoPluginManifest as T, type ResolvedPluginParts as U, type ResolvedPublicFrontendPart as V, applyConfigDefaults as W, configFieldLabel as X, declaredPartNames as Y, redactSecrets as Z, resolvePluginDeclares as _, type PluginBackendRuntime as a, resolvePluginScope as a0, restoreSecrets as a1, summarizeClawConfig as a2, summarizeConfigDeclaration as a3, type PluginScope as b, type PluginPartName as c, type PluginDeclares as d, type PluginConfigSection as e, type PluginConfigSectionSummary as f, type PluginNavIcon as g, type PluginNavEntry as h, type PluginAgentReadinessDeclaration as i, PLUGIN_BACKEND_PLATFORMS as j, PLUGIN_BACKEND_RUNTIMES as k, PLUGIN_CONFIG_SECRET_SENTINEL as l, PLUGIN_CONFIG_SECTIONS as m, PLUGIN_MANIFEST_FILENAME as n, PLUGIN_NAV_ICONS as o, PLUGIN_NAV_ICON_FALLBACK as p, PLUGIN_PART_DEFAULTS as q, PLUGIN_PART_NAMES as r, type PluginAgentReadinessItem as s, type PluginAgentReadinessResponse as t, type PluginAuditDeclarations as u, type PluginAuditToolDeclaration as v, type PluginBackendLimits as w, type PluginBackendPart as x, type PluginBackendPlatform as y, type PluginClawPart as z };