@openbrf/plugin-sdk 0.0.0-stage → 1.2.0

package/dist/manifest.d.ts

@@ -0,0 +1,1122 @@
+import { z } from "zod";
+import { type PluginManifestRule } from "./findings.ts";
+/**
+ * The plugin manifest.
+ *
+ * It lives in the `openbrf` field of the plugin's own package.json rather
+ * than in a separate file: npm already installs package.json, already
+ * validates its name and version, and already refuses to install a package
+ * without one. A second manifest file could go missing, disagree with the
+ * package it sits in, or be left behind by a partial extraction, and the
+ * loader would have to decide which of the two to believe.
+ */
+/**
+ * A plugin id.
+ *
+ * Used as a URL segment (`/api/plugin/<id>/...`), an i18n namespace
+ * (`plugin-<id>`), a database key and a directory name, so it is restricted to
+ * what is safe in all four. In particular it may not contain a dot or a
+ * slash: a plugin id is resolved against paths, and `..` must not be
+ * expressible.
+ */
+export declare const pluginIdSchema: z.ZodString;
+export declare const pluginEntrySchema: z.ZodObject<{
+    server: z.ZodOptional<z.ZodString>;
+    client: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * One action the plugin proposes.
+ *
+ * Declared in the manifest rather than at registration, because the board reads
+ * it on the install consent screen before anything has been downloaded, and
+ * nothing that can refuse a plugin may run after the code that executes it. The
+ * plugin's bundle supplies the schemas and the handler; what it may ask for is
+ * settled here.
+ *
+ * `capability` is a free string because this package cannot import the core
+ * capability union - it is published to plugin authors and the union is the
+ * instance's. It is resolved against the real list at the boot gate, which also
+ * refuses the ones no action of any kind may hold.
+ */
+export declare const pluginActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    capability: z.ZodString;
+    effect: z.ZodEnum<{
+        delete: "delete";
+        read: "read";
+        write: "write";
+    }>;
+    personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        account: "account";
+        apartment: "apartment";
+        auditTrail: "auditTrail";
+        email: "email";
+        financial: "financial";
+        freeText: "freeText";
+        health: "health";
+        name: "name";
+        personalIdentityNumber: "personalIdentityNumber";
+        phone: "phone";
+        photograph: "photograph";
+        postalAddress: "postalAddress";
+        protected: "protected";
+        residency: "residency";
+    }>>>;
+    surfaces: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        ai: "ai";
+        mcp: "mcp";
+        ui: "ui";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * The declared actions, as every boundary that reads them must read them.
+ *
+ * One schema rather than the same array written twice, because the invariant
+ * below has to hold at both: the catalog entry the consent screen renders from,
+ * and the manifest the loader enforces against it.
+ *
+ * An id appears once. Two declarations sharing one id are not a redundancy that
+ * sorts itself out - each of the three places that reads them resolves the
+ * collision differently. The binder takes the LAST, through a Map; consent
+ * compares canonical strings as a SET, so reordering the pair leaves the
+ * comparison equal and asks the board nothing; and arming stores the bare id,
+ * which names both. A republished version that only swapped the order of a
+ * duplicated pair would therefore keep its arming and go live at the OTHER
+ * declaration's capability, personal data and surfaces, with nobody having
+ * decided that. An action is one operation with one capability; two of them
+ * wearing one id is not a declaration this can read.
+ *
+ * Undefaulted, so each use site says for itself whether an absent list means
+ * "none declared" or "you did not answer". A manifest and a catalog entry mean
+ * the first and add `.default([])`; the install request means the second, since
+ * a board's echo that silently became an empty list would read as consent to no
+ * action at all - and a plugin that declares one would then be refused with a
+ * mismatch nothing the board could do would satisfy.
+ */
+export declare const pluginActionsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    capability: z.ZodString;
+    effect: z.ZodEnum<{
+        delete: "delete";
+        read: "read";
+        write: "write";
+    }>;
+    personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        account: "account";
+        apartment: "apartment";
+        auditTrail: "auditTrail";
+        email: "email";
+        financial: "financial";
+        freeText: "freeText";
+        health: "health";
+        name: "name";
+        personalIdentityNumber: "personalIdentityNumber";
+        phone: "phone";
+        photograph: "photograph";
+        postalAddress: "postalAddress";
+        protected: "protected";
+        residency: "residency";
+    }>>>;
+    surfaces: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        ai: "ai";
+        mcp: "mcp";
+        ui: "ui";
+    }>>>;
+}, z.core.$strip>>;
+/**
+ * The declared actions over a given reading of one action.
+ *
+ * The manifest reads an action as `pluginActionSchema` does; the catalog index
+ * reads the same fields strictly, because the index refuses a field its
+ * version does not define. Both keep the rule above, which is why the list is
+ * built here rather than written again.
+ */
+export declare function declaredActionsSchema<T extends z.ZodType<{
+    id: string;
+}>>(action: T): z.ZodArray<T>;
+/**
+ * The public name a declared action is offered under.
+ *
+ * The plugin's id with dashes folded to underscores, then the action's id. The
+ * folding has a consequence worth knowing: a plugin `a-b` declaring `c` and a
+ * plugin `a` declaring `b_c` compose the same name, so the registry refuses the
+ * second one to arrive and docs/plugin-contract.md says so.
+ */
+export declare function composedActionName(pluginId: string, actionId: string): string;
+/**
+ * The sections of the application's navigation a plugin's view may stand in.
+ *
+ * The application's own four, in the order its band shows them: the
+ * association and its life, the building and the apartments in it, the board's
+ * own desk, and the settings. A plugin names one of them rather than a section
+ * of its own, so a view is found where a destination of its kind already is.
+ */
+export declare const PLUGIN_VIEW_SECTIONS: readonly ["association", "building", "board", "settings"];
+export type PluginViewSection = (typeof PLUGIN_VIEW_SECTIONS)[number];
+export declare const pluginViewSchema: z.ZodObject<{
+    module: z.ZodDefault<z.ZodString>;
+    titleKey: z.ZodString;
+    section: z.ZodOptional<z.ZodEnum<{
+        association: "association";
+        board: "board";
+        building: "building";
+        settings: "settings";
+    }>>;
+}, z.core.$strip>;
+/** The id of an extension point, unique within the plugin that declares it. */
+export declare const extensionPointIdSchema: z.ZodString;
+/**
+ * One extension point the plugin offers other plugins (ADR 0030).
+ *
+ * Declared here rather than at registration for the reason an action is: the
+ * board reads what the point accepts on the consent screen before anything is
+ * downloaded. The bundle supplies the schemas; what may cross is settled here.
+ */
+export declare const pluginExtensionPointSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodInt;
+    personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        account: "account";
+        apartment: "apartment";
+        auditTrail: "auditTrail";
+        email: "email";
+        financial: "financial";
+        freeText: "freeText";
+        health: "health";
+        name: "name";
+        personalIdentityNumber: "personalIdentityNumber";
+        phone: "phone";
+        photograph: "photograph";
+        postalAddress: "postalAddress";
+        protected: "protected";
+        residency: "residency";
+    }>>>;
+}, z.core.$strip>;
+/** One extension point of another plugin that this plugin extends. */
+export declare const pluginExtensionSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    point: z.ZodString;
+    version: z.ZodInt;
+    personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        account: "account";
+        apartment: "apartment";
+        auditTrail: "auditTrail";
+        email: "email";
+        financial: "financial";
+        freeText: "freeText";
+        health: "health";
+        name: "name";
+        personalIdentityNumber: "personalIdentityNumber";
+        phone: "phone";
+        photograph: "photograph";
+        postalAddress: "postalAddress";
+        protected: "protected";
+        residency: "residency";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * The declared extension points over a given reading of one point.
+ *
+ * The manifest reads a point as `pluginExtensionPointSchema` does; the catalog
+ * index reads it strictly and with the curator's title and description. Both
+ * keep the rule that an id appears once, which is why the list is built here.
+ */
+export declare function declaredExtensionPointsSchema<T extends z.ZodType<{
+    id: string;
+}>>(point: T): z.ZodArray<T>;
+/**
+ * The declared extensions over a given reading of one, each pair of plugin and
+ * point once: an addon contributes once to each point it extends.
+ */
+export declare function declaredExtensionsSchema<T extends z.ZodType<{
+    plugin: string;
+    point: string;
+}>>(extension: T): z.ZodArray<T>;
+/** What the rules between a plugin's extension declarations read. */
+export interface ExtensionDeclarations {
+    readonly id: string;
+    readonly permissions: readonly string[];
+    readonly personalData: readonly string[];
+    readonly extensionPoints: readonly {
+        readonly personalData: readonly string[];
+    }[];
+    readonly extends: readonly {
+        readonly plugin: string;
+        readonly personalData: readonly string[];
+    }[];
+}
+/**
+ * The rules between a plugin's extension declarations and the rest of its
+ * declaration (ADR 0030), as issues with the path each one is at.
+ *
+ * One function for the manifest and the catalog entry, so an entry the loader
+ * would refuse is never offered for consent.
+ */
+export declare function extensionRuleIssues(declaration: ExtensionDeclarations): {
+    path: (string | number)[];
+    message: string;
+}[];
+/**
+ * The permissions that keep an addon and the plugin it extends apart, or an
+ * empty list when there are none (ADR 0030): those of whichever of the two
+ * does not ask for `site:blocks` that read the register or propose an import,
+ * when the other does.
+ *
+ * A plugin that asks for `site:blocks` reads nothing in the register and holds
+ * no member list, so what it publishes cannot name a resident. An extension is
+ * a path between two plugins in both directions: the host hands the addon the
+ * point's input, and the addon hands the host its output. A website host's
+ * points accept no personal data, but an addon that reads the register, or
+ * holds the member list it proposes, could still return a name in a field the
+ * point types as text, and only the addon's own `personalData` would say it
+ * does not. A website addon extending such a host could be handed names as the
+ * point's input, keep them, and render them in a block. So the rule reads what
+ * each side can reach, from the two manifests, rather than what either
+ * declares it hands over. Like the rule on a single plugin, it holds an honest
+ * pair to the website's argument rather than a hostile one.
+ */
+export declare function extensionPermissionsRefused(addon: {
+    readonly permissions: readonly string[];
+}, host: {
+    readonly permissions: readonly string[];
+}): string[];
+/**
+ * The personal data a plugin handles that keeps an addon asking for
+ * `site:blocks` off it, or an empty list when there is none (ADR 0030): the
+ * host plugin's own `personalData`, when the addon asks for `site:blocks`.
+ *
+ * The point's input is the one thing that crosses an extension and that no
+ * manifest declares. A host plugin that reads nothing in the register can
+ * still be handed names by another of its addons, and then hand them on as a
+ * point's input. A host plugin that handles no personal data has none to hand
+ * on, so a website addon extends only such a plugin.
+ */
+export declare function extensionHostPersonalDataRefused(addon: {
+    readonly permissions: readonly string[];
+}, host: {
+    readonly personalData: readonly string[];
+}): string[];
+/** Why a plugin's point cannot serve an addon's extension of it. */
+export type ExtensionPointRefusal = {
+    readonly reason: "extension-point-unknown";
+} | {
+    readonly reason: "extension-version-unsupported";
+    readonly supported: number;
+} | {
+    readonly reason: "extension-personal-data-refused";
+    readonly categories: string[];
+};
+/**
+ * Why the host plugin's points cannot serve an addon's extension, or null when
+ * they can (ADR 0030): the host declares no such point, declares it at another
+ * major version, or the point does not accept a personal-data category the
+ * addon hands over.
+ *
+ * Both the loader and the catalog read this, so an index that lists an addon
+ * beside the plugin it extends is refused for the three refusals the loader
+ * would give those two declarations. What the installed packages declare is
+ * the loader's to read.
+ */
+export declare function extensionPointRefusal(extension: {
+    readonly point: string;
+    readonly version: number;
+    readonly personalData: readonly string[];
+}, hostPoints: readonly {
+    readonly id: string;
+    readonly version: number;
+    readonly personalData: readonly string[];
+}[]): ExtensionPointRefusal | null;
+/** What the rule on a group of plugins joined by extensions reads. */
+export interface ExtensionGroupMember {
+    readonly id: string;
+    readonly permissions: readonly string[];
+    readonly extends: readonly {
+        readonly plugin: string;
+    }[];
+}
+/** Why an addon's group keeps it from serving. */
+export interface ExtensionGroupRefusal {
+    /** The plugins in its group that ask for `site:blocks`. */
+    readonly website: string[];
+    /**
+     * The plugins in its group that read the register or propose an import,
+     * and so reach the members' details.
+     */
+    readonly register: string[];
+}
+/**
+ * The addons refused because the plugins joined to them by extensions hold
+ * both a plugin that asks for `site:blocks` and one that reads the register or
+ * proposes an import, by id (ADR 0030).
+ *
+ * The rule between an addon and its host plugin reads two manifests. Data
+ * also crosses between two addons of one host plugin, and further: an addon
+ * that reads the register, or holds the member list it proposes, hands the
+ * host plugin a name while declaring nothing, the host plugin hands it to a
+ * website addon as a point's input, and the website addon renders it. Neither manifest of any one pair says so.
+ * So the plugins joined by extensions, through one host plugin or several,
+ * are read as one group, and a group never holds both kinds.
+ *
+ * The answer depends only on the set of members, never on their order, so it
+ * is the same whichever order the loader finds the packages in. Addons give
+ * way in the order of `GROUP_YIELDS`, which keeps the plugin that reads the
+ * register or proposes an import serving and refuses the website addon beside
+ * it.
+ */
+export declare function extensionGroupRefusals(members: readonly ExtensionGroupMember[]): Map<string, ExtensionGroupRefusal>;
+/**
+ * One device route: a path under the plugin's own mount that answers to a
+ * device token and to nothing else (ADR 0031).
+ *
+ * Declared in the manifest because the board reads it on the install consent
+ * screen, and because the guard has to know which paths take no session cookie
+ * before any of the plugin's code has run.
+ */
+export declare const pluginDeviceRouteSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/** At most this many device routes per plugin. */
+export declare const MAX_DEVICE_ROUTES = 4;
+/**
+ * Whether one route path is the other or lies below it, segment by segment.
+ *
+ * `screen` and `screen/pictures` overlap; `screen` and `screens` do not.
+ */
+export declare function routePathsOverlap(left: string, right: string): boolean;
+/**
+ * The declared device routes, as every boundary that reads them must read
+ * them: the manifest and the catalog entry the consent screen renders from.
+ *
+ * An id names one route, and no two routes overlap. A token is issued for one
+ * route by its id, and a request is matched to one route by its path, so a
+ * duplicated id or a path inside another route's would leave the guard two
+ * answers to choose from.
+ */
+export declare function declaredDeviceRoutesSchema<T extends z.ZodType<{
+    id: string;
+    path: string;
+}>>(route: T): z.ZodArray<T>;
+export declare const pluginDeviceRoutesSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * The rules a declaration of device routes has to keep beside the rest of the
+ * manifest, for the manifest and the catalog entry alike.
+ *
+ * A device route may not overlap the OAuth protected resource, which takes a
+ * different token on its own branch of the guard, and a plugin with a device
+ * route reads nothing from the register: a device is a screen on a wall that
+ * anyone passing reads (ADR 0031).
+ */
+export declare function deviceRouteRuleIssues(declaration: {
+    deviceRoutes: readonly {
+        id: string;
+        path: string;
+    }[];
+    oauthProtectedResource?: string | undefined;
+    permissions: readonly string[];
+}): {
+    path: (string | number)[];
+    message: string;
+    rule: PluginManifestRule;
+}[];
+/**
+ * What a plugin that proposes an import declares about the data it carries,
+ * for the manifest and the catalog entry alike (ADR 0043).
+ *
+ * The file is the association's member list, and the plugin carries it
+ * whole: every name, contact detail and personal identity number, and rows
+ * about persons with protected personal data, which the file does not mark.
+ * So the board is told so on the consent screen. And no other plugin can reach
+ * an identity number or a protected person, so for any other plugin either
+ * category would describe something that cannot happen.
+ */
+export declare function proposeImportPersonalDataIssues(declaration: {
+    permissions: readonly string[];
+    personalData: readonly string[];
+}): {
+    message: string;
+}[];
+/**
+ * A calendar date written `YYYY-MM-DD`, and a real one: `2027-02-30` is
+ * refused rather than rolled over into March.
+ */
+export declare function isCalendarDay(text: string): boolean;
+/**
+ * Which of an issuer's keys signed a licence (ADR 0042).
+ *
+ * It selects the keys to try and asserts nothing: two plugins may declare one
+ * key id with different keys, and a key is known by its fingerprint.
+ */
+export declare const licenceKeyIdSchema: z.ZodString;
+/**
+ * An Ed25519 public key: the base64 of its 32 raw bytes, padded, and in the
+ * one spelling that decodes to them. The last character before the padding
+ * carries two bits no key has, which is what the class of letters it may be
+ * from says.
+ */
+export declare const licencePublicKeySchema: z.ZodString;
+/**
+ * A service a plugin may present the instance's licence to: an `https` origin
+ * as the WHATWG URL standard serialises one, so it compares exactly.
+ *
+ * A lower-case domain in punycode, a port only when it is not 443, and no
+ * userinfo, path, query or fragment. A host whose last label is a number is
+ * an IPv4 address to that standard, which serialises it otherwise, so it is
+ * refused rather than compared in a form no browser would print. Plain `http`
+ * is refused too: a presentation sent in the clear could be replayed before
+ * the service saw its nonce.
+ */
+export declare const licenceAudienceSchema: z.ZodString;
+/**
+ * The licence a paid plugin reads (ADR 0042), and whom it trusts to issue it.
+ *
+ * The keys sit here rather than in the core, so the core holds no vendor's
+ * key and anyone who sells a plugin can issue licences for it in the same
+ * format. The host verifies; a plugin reads the result through
+ * `host.entitlements`.
+ *
+ * Strict, because what it grants is consented to: a misspelled field read as
+ * absent would be a declaration the board never saw.
+ */
+export declare const pluginLicenceSchema: z.ZodObject<{
+    entitlement: z.ZodString;
+    issuer: z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strict>;
+    keys: z.ZodRecord<z.ZodString, z.ZodString>;
+    audiences: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type PluginLicenceDeclaration = z.infer<typeof pluginLicenceSchema>;
+export declare const pluginManifestSchema: z.ZodObject<{
+    apiVersion: z.ZodInt;
+    id: z.ZodString;
+    entry: z.ZodObject<{
+        server: z.ZodOptional<z.ZodString>;
+        client: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "addressBook:proposeImport": "addressBook:proposeImport";
+        "addressBook:read": "addressBook:read";
+        "addressBook:readContact": "addressBook:readContact";
+        "addresses:read": "addresses:read";
+        "bookings:readAvailability": "bookings:readAvailability";
+        "calendar:read": "calendar:read";
+        "finances:read": "finances:read";
+        "finances:recordDelivery": "finances:recordDelivery";
+        "jobs:schedule": "jobs:schedule";
+        "mail:send": "mail:send";
+        "media:read": "media:read";
+        "news:read": "news:read";
+        "site:blocks": "site:blocks";
+        "sms:send": "sms:send";
+        "themes:install": "themes:install";
+    }>>>;
+    personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        account: "account";
+        apartment: "apartment";
+        auditTrail: "auditTrail";
+        email: "email";
+        financial: "financial";
+        freeText: "freeText";
+        health: "health";
+        name: "name";
+        personalIdentityNumber: "personalIdentityNumber";
+        phone: "phone";
+        photograph: "photograph";
+        postalAddress: "postalAddress";
+        protected: "protected";
+        residency: "residency";
+    }>>>;
+    settingsSchema: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            labelKey: z.ZodString;
+            hintKey: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            type: z.ZodLiteral<"text">;
+            default: z.ZodOptional<z.ZodString>;
+            minLength: z.ZodOptional<z.ZodInt>;
+            maxLength: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            labelKey: z.ZodString;
+            hintKey: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            type: z.ZodLiteral<"number">;
+            default: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            integer: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            labelKey: z.ZodString;
+            hintKey: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            type: z.ZodLiteral<"boolean">;
+            default: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            labelKey: z.ZodString;
+            hintKey: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            type: z.ZodLiteral<"select">;
+            default: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                labelKey: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            labelKey: z.ZodString;
+            hintKey: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            type: z.ZodLiteral<"secret">;
+            minLength: z.ZodOptional<z.ZodInt>;
+            maxLength: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>>;
+    view: z.ZodOptional<z.ZodObject<{
+        module: z.ZodDefault<z.ZodString>;
+        titleKey: z.ZodString;
+        section: z.ZodOptional<z.ZodEnum<{
+            association: "association";
+            board: "board";
+            building: "building";
+            settings: "settings";
+        }>>;
+    }, z.core.$strip>>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        effect: z.ZodEnum<{
+            delete: "delete";
+            read: "read";
+            write: "write";
+        }>;
+        personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            account: "account";
+            apartment: "apartment";
+            auditTrail: "auditTrail";
+            email: "email";
+            financial: "financial";
+            freeText: "freeText";
+            health: "health";
+            name: "name";
+            personalIdentityNumber: "personalIdentityNumber";
+            phone: "phone";
+            photograph: "photograph";
+            postalAddress: "postalAddress";
+            protected: "protected";
+            residency: "residency";
+        }>>>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            ai: "ai";
+            mcp: "mcp";
+            ui: "ui";
+        }>>>;
+    }, z.core.$strip>>>;
+    oauthProtectedResource: z.ZodOptional<z.ZodString>;
+    deviceRoutes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>>;
+    ai: z.ZodDefault<z.ZodBoolean>;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        labelKey: z.ZodString;
+        icon: z.ZodDefault<z.ZodEnum<{
+            calendar: "calendar";
+            contact: "contact";
+            documents: "documents";
+            facts: "facts";
+            form: "form";
+            heading: "heading";
+            image: "image";
+            news: "news";
+            paragraph: "paragraph";
+            people: "people";
+            plugin: "plugin";
+            questions: "questions";
+        }>>;
+        category: z.ZodDefault<z.ZodEnum<{
+            association: "association";
+            media: "media";
+            text: "text";
+        }>>;
+        settingsSchema: z.ZodDefault<z.ZodObject<{
+            fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"text">;
+                default: z.ZodOptional<z.ZodString>;
+                minLength: z.ZodOptional<z.ZodInt>;
+                maxLength: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"number">;
+                default: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                integer: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"boolean">;
+                default: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"select">;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    labelKey: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"secret">;
+                minLength: z.ZodOptional<z.ZodInt>;
+                maxLength: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>>;
+    extensionPoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodInt;
+        personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            account: "account";
+            apartment: "apartment";
+            auditTrail: "auditTrail";
+            email: "email";
+            financial: "financial";
+            freeText: "freeText";
+            health: "health";
+            name: "name";
+            personalIdentityNumber: "personalIdentityNumber";
+            phone: "phone";
+            photograph: "photograph";
+            postalAddress: "postalAddress";
+            protected: "protected";
+            residency: "residency";
+        }>>>;
+    }, z.core.$strip>>>;
+    extends: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        plugin: z.ZodString;
+        point: z.ZodString;
+        version: z.ZodInt;
+        personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            account: "account";
+            apartment: "apartment";
+            auditTrail: "auditTrail";
+            email: "email";
+            financial: "financial";
+            freeText: "freeText";
+            health: "health";
+            name: "name";
+            personalIdentityNumber: "personalIdentityNumber";
+            phone: "phone";
+            photograph: "photograph";
+            postalAddress: "postalAddress";
+            protected: "protected";
+            residency: "residency";
+        }>>>;
+    }, z.core.$strip>>>;
+    recipients: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        origin: z.ZodString;
+        purpose: z.ZodObject<{
+            sv: z.ZodString;
+            en: z.ZodString;
+        }, z.core.$strict>;
+        personalData: z.ZodArray<z.ZodEnum<{
+            account: "account";
+            apartment: "apartment";
+            auditTrail: "auditTrail";
+            email: "email";
+            financial: "financial";
+            freeText: "freeText";
+            health: "health";
+            name: "name";
+            personalIdentityNumber: "personalIdentityNumber";
+            phone: "phone";
+            photograph: "photograph";
+            postalAddress: "postalAddress";
+            protected: "protected";
+            residency: "residency";
+        }>>;
+    }, z.core.$strip>>>;
+    licence: z.ZodOptional<z.ZodObject<{
+        entitlement: z.ZodString;
+        issuer: z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>;
+        keys: z.ZodRecord<z.ZodString, z.ZodString>;
+        audiences: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    released: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginManifest = z.infer<typeof pluginManifestSchema>;
+export type PluginActionDeclaration = z.infer<typeof pluginActionSchema>;
+export type PluginEntry = z.infer<typeof pluginEntrySchema>;
+export type PluginView = z.infer<typeof pluginViewSchema>;
+export type PluginExtensionPointDeclaration = z.infer<typeof pluginExtensionPointSchema>;
+export type PluginExtensionDeclaration = z.infer<typeof pluginExtensionSchema>;
+export type PluginDeviceRoute = z.infer<typeof pluginDeviceRouteSchema>;
+/**
+ * Dependency fields npm installs at install time.
+ *
+ * The installer omits peer, dev and optional dependencies and runs no scripts,
+ * but it still hands npm the package: anything listed here would send that npm
+ * to a registry, which an instance never contacts. optionalDependencies is
+ * listed although it is omitted, because a package relying on one being
+ * present works in development and quietly not on an instance.
+ */
+export declare const RUNTIME_DEPENDENCY_FIELDS: readonly ["dependencies", "optionalDependencies", "bundleDependencies", "bundledDependencies"];
+/** Package names in a dependency field, whether a map or npm's bundle list. */
+export declare function dependencyNames(value: unknown): string[];
+/** Whether a dependency field is an empty map or an empty list. */
+export declare function isEmptyDependencyField(value: unknown): boolean;
+/**
+ * The subset of package.json the loader reads. Everything else in the file is
+ * npm's business, apart from the dependency fields, which must name nothing.
+ */
+export declare const pluginPackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    openbrf: z.ZodObject<{
+        apiVersion: z.ZodInt;
+        id: z.ZodString;
+        entry: z.ZodObject<{
+            server: z.ZodOptional<z.ZodString>;
+            client: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "addressBook:proposeImport": "addressBook:proposeImport";
+            "addressBook:read": "addressBook:read";
+            "addressBook:readContact": "addressBook:readContact";
+            "addresses:read": "addresses:read";
+            "bookings:readAvailability": "bookings:readAvailability";
+            "calendar:read": "calendar:read";
+            "finances:read": "finances:read";
+            "finances:recordDelivery": "finances:recordDelivery";
+            "jobs:schedule": "jobs:schedule";
+            "mail:send": "mail:send";
+            "media:read": "media:read";
+            "news:read": "news:read";
+            "site:blocks": "site:blocks";
+            "sms:send": "sms:send";
+            "themes:install": "themes:install";
+        }>>>;
+        personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            account: "account";
+            apartment: "apartment";
+            auditTrail: "auditTrail";
+            email: "email";
+            financial: "financial";
+            freeText: "freeText";
+            health: "health";
+            name: "name";
+            personalIdentityNumber: "personalIdentityNumber";
+            phone: "phone";
+            photograph: "photograph";
+            postalAddress: "postalAddress";
+            protected: "protected";
+            residency: "residency";
+        }>>>;
+        settingsSchema: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"text">;
+                default: z.ZodOptional<z.ZodString>;
+                minLength: z.ZodOptional<z.ZodInt>;
+                maxLength: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"number">;
+                default: z.ZodOptional<z.ZodNumber>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                integer: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"boolean">;
+                default: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"select">;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    labelKey: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                labelKey: z.ZodString;
+                hintKey: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                type: z.ZodLiteral<"secret">;
+                minLength: z.ZodOptional<z.ZodInt>;
+                maxLength: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>>;
+        view: z.ZodOptional<z.ZodObject<{
+            module: z.ZodDefault<z.ZodString>;
+            titleKey: z.ZodString;
+            section: z.ZodOptional<z.ZodEnum<{
+                association: "association";
+                board: "board";
+                building: "building";
+                settings: "settings";
+            }>>;
+        }, z.core.$strip>>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            effect: z.ZodEnum<{
+                delete: "delete";
+                read: "read";
+                write: "write";
+            }>;
+            personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                account: "account";
+                apartment: "apartment";
+                auditTrail: "auditTrail";
+                email: "email";
+                financial: "financial";
+                freeText: "freeText";
+                health: "health";
+                name: "name";
+                personalIdentityNumber: "personalIdentityNumber";
+                phone: "phone";
+                photograph: "photograph";
+                postalAddress: "postalAddress";
+                protected: "protected";
+                residency: "residency";
+            }>>>;
+            surfaces: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                ai: "ai";
+                mcp: "mcp";
+                ui: "ui";
+            }>>>;
+        }, z.core.$strip>>>;
+        oauthProtectedResource: z.ZodOptional<z.ZodString>;
+        deviceRoutes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+        ai: z.ZodDefault<z.ZodBoolean>;
+        blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            labelKey: z.ZodString;
+            icon: z.ZodDefault<z.ZodEnum<{
+                calendar: "calendar";
+                contact: "contact";
+                documents: "documents";
+                facts: "facts";
+                form: "form";
+                heading: "heading";
+                image: "image";
+                news: "news";
+                paragraph: "paragraph";
+                people: "people";
+                plugin: "plugin";
+                questions: "questions";
+            }>>;
+            category: z.ZodDefault<z.ZodEnum<{
+                association: "association";
+                media: "media";
+                text: "text";
+            }>>;
+            settingsSchema: z.ZodDefault<z.ZodObject<{
+                fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    key: z.ZodString;
+                    labelKey: z.ZodString;
+                    hintKey: z.ZodOptional<z.ZodString>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    type: z.ZodLiteral<"text">;
+                    default: z.ZodOptional<z.ZodString>;
+                    minLength: z.ZodOptional<z.ZodInt>;
+                    maxLength: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strip>, z.ZodObject<{
+                    key: z.ZodString;
+                    labelKey: z.ZodString;
+                    hintKey: z.ZodOptional<z.ZodString>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    type: z.ZodLiteral<"number">;
+                    default: z.ZodOptional<z.ZodNumber>;
+                    min: z.ZodOptional<z.ZodNumber>;
+                    max: z.ZodOptional<z.ZodNumber>;
+                    integer: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    key: z.ZodString;
+                    labelKey: z.ZodString;
+                    hintKey: z.ZodOptional<z.ZodString>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    type: z.ZodLiteral<"boolean">;
+                    default: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    key: z.ZodString;
+                    labelKey: z.ZodString;
+                    hintKey: z.ZodOptional<z.ZodString>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    type: z.ZodLiteral<"select">;
+                    default: z.ZodOptional<z.ZodString>;
+                    options: z.ZodArray<z.ZodObject<{
+                        value: z.ZodString;
+                        labelKey: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    key: z.ZodString;
+                    labelKey: z.ZodString;
+                    hintKey: z.ZodOptional<z.ZodString>;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    type: z.ZodLiteral<"secret">;
+                    minLength: z.ZodOptional<z.ZodInt>;
+                    maxLength: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strip>], "type">>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>>;
+        extensionPoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodInt;
+            personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                account: "account";
+                apartment: "apartment";
+                auditTrail: "auditTrail";
+                email: "email";
+                financial: "financial";
+                freeText: "freeText";
+                health: "health";
+                name: "name";
+                personalIdentityNumber: "personalIdentityNumber";
+                phone: "phone";
+                photograph: "photograph";
+                postalAddress: "postalAddress";
+                protected: "protected";
+                residency: "residency";
+            }>>>;
+        }, z.core.$strip>>>;
+        extends: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            plugin: z.ZodString;
+            point: z.ZodString;
+            version: z.ZodInt;
+            personalData: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                account: "account";
+                apartment: "apartment";
+                auditTrail: "auditTrail";
+                email: "email";
+                financial: "financial";
+                freeText: "freeText";
+                health: "health";
+                name: "name";
+                personalIdentityNumber: "personalIdentityNumber";
+                phone: "phone";
+                photograph: "photograph";
+                postalAddress: "postalAddress";
+                protected: "protected";
+                residency: "residency";
+            }>>>;
+        }, z.core.$strip>>>;
+        recipients: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            origin: z.ZodString;
+            purpose: z.ZodObject<{
+                sv: z.ZodString;
+                en: z.ZodString;
+            }, z.core.$strict>;
+            personalData: z.ZodArray<z.ZodEnum<{
+                account: "account";
+                apartment: "apartment";
+                auditTrail: "auditTrail";
+                email: "email";
+                financial: "financial";
+                freeText: "freeText";
+                health: "health";
+                name: "name";
+                personalIdentityNumber: "personalIdentityNumber";
+                phone: "phone";
+                photograph: "photograph";
+                postalAddress: "postalAddress";
+                protected: "protected";
+                residency: "residency";
+            }>>;
+        }, z.core.$strip>>>;
+        licence: z.ZodOptional<z.ZodObject<{
+            entitlement: z.ZodString;
+            issuer: z.ZodObject<{
+                name: z.ZodString;
+                url: z.ZodString;
+            }, z.core.$strict>;
+            keys: z.ZodRecord<z.ZodString, z.ZodString>;
+            audiences: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        released: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    dependencies: z.ZodOptional<z.ZodUnknown>;
+    optionalDependencies: z.ZodOptional<z.ZodUnknown>;
+    bundleDependencies: z.ZodOptional<z.ZodUnknown>;
+    bundledDependencies: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type PluginPackage = z.infer<typeof pluginPackageSchema>;
+export interface ManifestParseFailure {
+    ok: false;
+    /** One line per problem, already naming the field. */
+    issues: string[];
+    /**
+     * The same problems, each with the code of the rule it broke when it broke
+     * one a board reads in its own language (`PLUGIN_MANIFEST_RULES`), and null
+     * when it is a field's own problem.
+     */
+    diagnostics: {
+        rule: PluginManifestRule | null;
+        issue: string;
+    }[];
+}
+export type ManifestParseResult = {
+    ok: true;
+    value: PluginPackage;
+} | ManifestParseFailure;
+/**
+ * Parses a plugin's package.json.
+ *
+ * Returns a result rather than throwing, because the only caller that matters
+ * is the boot-time scan, and a malformed plugin directory must be skipped and
+ * reported rather than being allowed to take the register offline (ADR 0003).
+ * A thrown error would make "skip and report" the caller's discipline instead
+ * of the function's contract.
+ */
+export declare function parsePluginPackage(input: unknown): ManifestParseResult;
+/** Convenience for a plugin's own CI: throws with every problem at once. */
+export declare function assertPluginPackage(input: unknown): PluginPackage;
+/** The api version a plugin authored against this SDK should declare. */
+export declare const CURRENT_PLUGIN_API_VERSION = 1;
+//# sourceMappingURL=manifest.d.ts.map