@tai42/api-client 16.0.0 → 17.0.0

package/dist/schemas/marketplace.d.ts

@@ -0,0 +1,708 @@
+/** Marketplace listing, version, install and advisory schemas. */
+import { z } from 'zod';
+/**
+ * The CLOSED HTTP-method enum fixed by the contract's RouteMethod, the one source
+ * for every route-method field (declaration and install/preview responses alike):
+ * a wire method the contract does not define fails loudly as drift rather than
+ * passing through silently.
+ */
+export declare const routeMethod: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+}>;
+export type RouteMethod = z.infer<typeof routeMethod>;
+/**
+ * How the plugin is delivered, derived server-side from whether its spec names a
+ * package: `package` is pip-installed, `descriptor` (marketplace `source` `spec`)
+ * installs nothing but the manifest entry. A CLOSED enum, so a wire value the
+ * server does not derive fails loudly as drift.
+ */
+export declare const marketplaceDelivery: z.ZodEnum<{
+    package: "package";
+    descriptor: "descriptor";
+}>;
+export type MarketplaceDelivery = z.infer<typeof marketplaceDelivery>;
+/**
+ * The install-provenance vocabulary a listing/version resolves from: a pip index
+ * (`pypi`), a git tag (`github`), or a descriptor yml (`spec`). CLOSED, so a wire
+ * value outside it fails as drift.
+ */
+export declare const marketplaceSource: z.ZodEnum<{
+    pypi: "pypi";
+    github: "github";
+    spec: "spec";
+}>;
+export type MarketplaceSource = z.infer<typeof marketplaceSource>;
+/**
+ * One env var an item requires before install: its `name` and whether its value is
+ * a `secret` (an OAuth client secret is; a client id or a plain marker var is not).
+ * The install dialog seeds each toggle from `secret` and collects the missing ones.
+ */
+export declare const marketplaceRequiredEnvVar: z.ZodObject<{
+    name: z.ZodString;
+    secret: z.ZodBoolean;
+}, z.core.$strip>;
+export type MarketplaceRequiredEnvVar = z.infer<typeof marketplaceRequiredEnvVar>;
+/**
+ * One HTTP route an item declares in its `tai-plugin.yml`: a `path` relative to
+ * the item's mount base, the `methods` it answers, and whether it is served
+ * `public` (without authentication). The absolute path an operator sees is
+ * resolved from the base at install time.
+ */
+export declare const marketplaceRouteDecl: z.ZodObject<{
+    path: z.ZodString;
+    methods: z.ZodArray<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+    public: z.ZodBoolean;
+}, z.core.$strip>;
+export type MarketplaceRouteDecl = z.infer<typeof marketplaceRouteDecl>;
+/**
+ * A route-carrying item's declared mount: the default `base` prefix the routes
+ * hang off (an operator may remap it at install) and the `paths` it registers.
+ */
+export declare const marketplaceRoutesDecl: z.ZodObject<{
+    base: z.ZodString;
+    paths: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        public: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplaceRoutesDecl = z.infer<typeof marketplaceRoutesDecl>;
+/**
+ * One contained item of a marketplace plugin's published version: its kind
+ * (tool / agent / extension / …), name, description, free-form tags, and the
+ * logical group it belongs to (`null` when ungrouped). `routes` is present only
+ * on a route-carrying item (a router or channel); absent/null on every other.
+ * `required_env` is the env vars the item needs before install — but the REGISTRY's
+ * plugin-detail body does NOT carry it per item: required-env is server-computed
+ * (`required_env_for_spec`) and rides the install PREVIEW, never the listing detail,
+ * so the registry OMITS it here and it parses as `undefined`. Optional (not
+ * defaulted) so the type mirrors the wire; the authority the install dialog collects
+ * from is the preview's `required_env`/`missing_env`, never this field.
+ */
+export declare const marketplaceItem: z.ZodObject<{
+    kind: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    group: z.ZodNullable<z.ZodString>;
+    routes: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        base: z.ZodString;
+        paths: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            methods: z.ZodArray<z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            public: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    required_env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        secret: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MarketplaceItem = z.infer<typeof marketplaceItem>;
+/**
+ * One kind summary of a search row: an item kind, how many UNGROUPED items of
+ * that kind the listing's latest published version carries, and their names.
+ * The registry orders the array count DESC then kind ASC, and each entry's
+ * `names` ASC; the UI renders in that order.
+ */
+export declare const marketplaceSearchKind: z.ZodObject<{
+    kind: z.ZodString;
+    count: z.ZodNumber;
+    names: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type MarketplaceSearchKind = z.infer<typeof marketplaceSearchKind>;
+/**
+ * One logical group of a search row: the group name and how many items the
+ * listing's latest published version places in it. The registry orders the
+ * array count DESC then name ASC; the UI renders in that order.
+ */
+export declare const marketplaceSearchGroup: z.ZodObject<{
+    name: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type MarketplaceSearchGroup = z.infer<typeof marketplaceSearchGroup>;
+/**
+ * One listing-level search row (`GET /api/marketplace/search`). `ref` is the
+ * "namespace/name" install target, so every row carries enough to link to its
+ * plugin. `latest_version` is nullable defensively; the search relation only
+ * emits listings with a published version. `kinds` summarizes that latest
+ * version's UNGROUPED items; `groups` summarizes its logical groups (`[]` when
+ * none). Both keys are always present.
+ */
+export declare const marketplaceSearchRow: z.ZodObject<{
+    ref: z.ZodString;
+    namespace: z.ZodString;
+    name: z.ZodString;
+    display_name: z.ZodNullable<z.ZodString>;
+    icon_url: z.ZodNullable<z.ZodString>;
+    package: z.ZodNullable<z.ZodString>;
+    description: z.ZodString;
+    categories: z.ZodArray<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    trust_tier: z.ZodString;
+    pricing: z.ZodString;
+    premium: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    latest_version: z.ZodNullable<z.ZodString>;
+    downloads: z.ZodNumber;
+    updated_at: z.ZodString;
+    kinds: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        count: z.ZodNumber;
+        names: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    groups: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplaceSearchRow = z.infer<typeof marketplaceSearchRow>;
+/**
+ * One page of listing rows. The wire carries no next-page field — has-next is
+ * COMPUTED: `page * page_size < total`.
+ */
+export declare const marketplaceSearchPage: z.ZodObject<{
+    listings: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        namespace: z.ZodString;
+        name: z.ZodString;
+        display_name: z.ZodNullable<z.ZodString>;
+        icon_url: z.ZodNullable<z.ZodString>;
+        package: z.ZodNullable<z.ZodString>;
+        description: z.ZodString;
+        categories: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        trust_tier: z.ZodString;
+        pricing: z.ZodString;
+        premium: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        latest_version: z.ZodNullable<z.ZodString>;
+        downloads: z.ZodNumber;
+        updated_at: z.ZodString;
+        kinds: z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            count: z.ZodNumber;
+            names: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        groups: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    page_size: z.ZodNumber;
+}, z.core.$strip>;
+export type MarketplaceSearchPage = z.infer<typeof marketplaceSearchPage>;
+/**
+ * One version of a listing as the versions list carries it (`version`, its
+ * publication `status`, the `contract_range` it was validated against, and when
+ * it was `published_at`). `contract_range` and `published_at` are null until a
+ * version reaches the published state, so both are nullable.
+ */
+export declare const marketplaceVersion: z.ZodObject<{
+    version: z.ZodString;
+    contract_range: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    published_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type MarketplaceVersion = z.infer<typeof marketplaceVersion>;
+/**
+ * The listing's latest published version as embedded in its detail: the version
+ * (with the `marketplaceVersion` lifecycle fields) and the items it contains. The
+ * registry's detail body carries NO per-version `delivery` field — delivery is
+ * server-computed from whether the spec names a package, and the detail surface
+ * derives it from the listing's `package` (null ⇒ `descriptor`, else `package`).
+ * Env to collect comes from the install preview (`required_env` / `missing_env`),
+ * never from these items.
+ */
+export declare const marketplaceLatestVersion: z.ZodObject<{
+    version: z.ZodString;
+    contract_range: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+    published_at: z.ZodNullable<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        group: z.ZodNullable<z.ZodString>;
+        routes: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            base: z.ZodString;
+            paths: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                methods: z.ZodArray<z.ZodEnum<{
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                    DELETE: "DELETE";
+                }>>;
+                public: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        required_env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            secret: z.ZodBoolean;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplaceLatestVersion = z.infer<typeof marketplaceLatestVersion>;
+/** One advisory row; `withdrawn_at` non-null means it no longer applies. */
+export declare const marketplaceAdvisory: z.ZodObject<{
+    id: z.ZodNumber;
+    listing: z.ZodString;
+    affected_versions: z.ZodString;
+    severity: z.ZodString;
+    summary: z.ZodString;
+    created_at: z.ZodString;
+    withdrawn_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type MarketplaceAdvisory = z.infer<typeof marketplaceAdvisory>;
+/**
+ * A plugin's full detail (`GET /api/marketplace/plugins/{ns}/{name}`): the
+ * listing, its latest published version (`null` when nothing is published yet,
+ * carrying the contained items), and the known version history.
+ */
+export declare const marketplacePluginDetail: z.ZodObject<{
+    namespace: z.ZodString;
+    name: z.ZodString;
+    display_name: z.ZodNullable<z.ZodString>;
+    icon_url: z.ZodNullable<z.ZodString>;
+    package: z.ZodNullable<z.ZodString>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        pypi: "pypi";
+        github: "github";
+        spec: "spec";
+    }>>>;
+    description: z.ZodString;
+    readme_md: z.ZodNullable<z.ZodString>;
+    license: z.ZodNullable<z.ZodString>;
+    homepage_url: z.ZodNullable<z.ZodString>;
+    repository_url: z.ZodNullable<z.ZodString>;
+    docs_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    categories: z.ZodArray<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    trust_tier: z.ZodString;
+    pricing: z.ZodString;
+    premium: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    downloads: z.ZodNumber;
+    latest: z.ZodNullable<z.ZodObject<{
+        version: z.ZodString;
+        contract_range: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        published_at: z.ZodNullable<z.ZodString>;
+        items: z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+            group: z.ZodNullable<z.ZodString>;
+            routes: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                base: z.ZodString;
+                paths: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    methods: z.ZodArray<z.ZodEnum<{
+                        GET: "GET";
+                        POST: "POST";
+                        PUT: "PUT";
+                        PATCH: "PATCH";
+                        DELETE: "DELETE";
+                    }>>;
+                    public: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            required_env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                secret: z.ZodBoolean;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    versions: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        contract_range: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        published_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplacePluginDetail = z.infer<typeof marketplacePluginDetail>;
+/**
+ * One installed plugin's compat verdict against the RUNNING tai42-contract:
+ * `compatible` / `incompatible` per its declared contract range, `unknown` when
+ * no verdict could be computed. `reason` is the human-readable explanation of a
+ * non-`compatible` verdict, `null` when compatible. CLOSED (`.strict()`): the
+ * server is built against exactly this shape, so an unknown key is drift and
+ * throws instead of being stripped.
+ */
+export declare const marketplaceInstalledCompat: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        compatible: "compatible";
+        incompatible: "incompatible";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type MarketplaceInstalledCompat = z.infer<typeof marketplaceInstalledCompat>;
+/**
+ * One installed marketplace plugin as the local attribution store records it.
+ * `latest` is the newest registry version (`null` when unknown);
+ * `update_available` advertises only a newer COMPATIBLE version, and
+ * `incompatible_newer` names the newest version blocked by the running
+ * contract (`null` when none), so "an update exists but needs a newer core" is
+ * visible. `missing_upstream` flags a plugin the registry no longer lists.
+ * `compat` is the row's verdict against the running contract. CLOSED, like
+ * every shape of the installed listing.
+ */
+export declare const marketplaceInstalledPlugin: z.ZodObject<{
+    ref: z.ZodString;
+    version: z.ZodString;
+    source: z.ZodString;
+    delivery: z.ZodEnum<{
+        package: "package";
+        descriptor: "descriptor";
+    }>;
+    installed_at: z.ZodString;
+    latest: z.ZodNullable<z.ZodString>;
+    update_available: z.ZodBoolean;
+    incompatible_newer: z.ZodNullable<z.ZodString>;
+    missing_upstream: z.ZodBoolean;
+    compat: z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            compatible: "compatible";
+            incompatible: "incompatible";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$strip>>;
+    route_mounts: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+export type MarketplaceInstalledPlugin = z.infer<typeof marketplaceInstalledPlugin>;
+/** One plugin the boot pass quarantined instead of loading, with why. CLOSED. */
+export declare const marketplaceQuarantinedPlugin: z.ZodObject<{
+    name: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type MarketplaceQuarantinedPlugin = z.infer<typeof marketplaceQuarantinedPlugin>;
+/**
+ * The installed inventory (`GET /api/marketplace/installed`): the attributed
+ * rows plus every plugin the boot pass quarantined instead of loading. CLOSED.
+ */
+export declare const marketplaceInstalled: z.ZodObject<{
+    installed: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        source: z.ZodString;
+        delivery: z.ZodEnum<{
+            package: "package";
+            descriptor: "descriptor";
+        }>;
+        installed_at: z.ZodString;
+        latest: z.ZodNullable<z.ZodString>;
+        update_available: z.ZodBoolean;
+        incompatible_newer: z.ZodNullable<z.ZodString>;
+        missing_upstream: z.ZodBoolean;
+        compat: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                compatible: "compatible";
+                incompatible: "incompatible";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        items: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodString;
+        }, z.core.$strip>>;
+        route_mounts: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+    quarantined: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MarketplaceInstalled = z.infer<typeof marketplaceInstalled>;
+/**
+ * One per-plugin outcome of `POST /api/marketplace/upgrade-all`: `upgraded`,
+ * already `up-to-date`, `no-compatible-version` in the registry, or `failed`;
+ * `detail` always carries the human-readable specifics. CLOSED.
+ */
+export declare const marketplaceUpgradeAllRow: z.ZodObject<{
+    ref: z.ZodString;
+    outcome: z.ZodEnum<{
+        failed: "failed";
+        upgraded: "upgraded";
+        "up-to-date": "up-to-date";
+        "no-compatible-version": "no-compatible-version";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strict>;
+export type MarketplaceUpgradeAllRow = z.infer<typeof marketplaceUpgradeAllRow>;
+/** The whole upgrade-all readout: one outcome row per installed plugin. CLOSED. */
+export declare const marketplaceUpgradeAllResult: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        outcome: z.ZodEnum<{
+            failed: "failed";
+            upgraded: "upgraded";
+            "up-to-date": "up-to-date";
+            "no-compatible-version": "no-compatible-version";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MarketplaceUpgradeAllResult = z.infer<typeof marketplaceUpgradeAllResult>;
+/** The advisory state for installed plugins, with when it was last fetched. */
+export declare const marketplaceAdvisories: z.ZodObject<{
+    advisories: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        listing: z.ZodString;
+        affected_versions: z.ZodString;
+        severity: z.ZodString;
+        summary: z.ZodString;
+        created_at: z.ZodString;
+        withdrawn_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    fetched_at: z.ZodString;
+}, z.core.$strip>;
+/** The registry's controlled category list, proxied through the skeleton. */
+export declare const marketplaceCategories: z.ZodArray<z.ZodString>;
+/** The registry's controlled item-kind list, proxied through the skeleton. */
+export declare const marketplaceKinds: z.ZodArray<z.ZodString>;
+/**
+ * One route the install / update actually mounted: the item that owns it, the
+ * absolute `full_path` it now answers, the `methods`, and whether it is served
+ * `public`. The receipt lists these so the operator sees what was opened where.
+ */
+export declare const marketplaceMountedRoute: z.ZodObject<{
+    item: z.ZodString;
+    full_path: z.ZodString;
+    methods: z.ZodArray<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+    public: z.ZodBoolean;
+}, z.core.$strip>;
+export type MarketplaceMountedRoute = z.infer<typeof marketplaceMountedRoute>;
+/**
+ * The receipt of an install / update: what landed and at which version.
+ * `notes` (env-selected items naming their activating env var) and any
+ * non-critical `advisories` ride BOTH the install and update receipts.
+ * `routes` is the mounted-route list — empty for a plugin that registers none.
+ * The wire also carries `package`, `reload`, and `pip_output`, which the receipt
+ * does not model — zod's default strip drops them; the UI renders the receipt,
+ * not the raw install log.
+ */
+export declare const marketplaceInstallResult: z.ZodObject<{
+    ref: z.ZodString;
+    version: z.ZodString;
+    notes: z.ZodArray<z.ZodString>;
+    advisories: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        listing: z.ZodString;
+        affected_versions: z.ZodString;
+        severity: z.ZodString;
+        summary: z.ZodString;
+        created_at: z.ZodString;
+        withdrawn_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    routes: z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        full_path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        public: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplaceInstallResult = z.infer<typeof marketplaceInstallResult>;
+/** One resolved route in an install preview: the declared `path`, its resolved
+ * absolute `full_path`, the `methods`, and whether it is `public`. */
+export declare const marketplacePreviewRoute: z.ZodObject<{
+    path: z.ZodString;
+    full_path: z.ZodString;
+    methods: z.ZodArray<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+    public: z.ZodBoolean;
+}, z.core.$strip>;
+export type MarketplacePreviewRoute = z.infer<typeof marketplacePreviewRoute>;
+/** One route-carrying item in an install preview: its resolved `base` (the
+ * override or the default), the `default_base` it declares, and the routes that
+ * mount under it. */
+export declare const marketplacePreviewItem: z.ZodObject<{
+    item: z.ZodString;
+    kind: z.ZodString;
+    base: z.ZodString;
+    default_base: z.ZodString;
+    routes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        full_path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        public: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MarketplacePreviewItem = z.infer<typeof marketplacePreviewItem>;
+/** One collision the preview found: a route whose resolved shape+method clashes
+ * with an already-owned route. `conflict_owner` is `core` or `plugin:<ref>`; the
+ * remedy is to remap the item's base. */
+export declare const marketplacePreviewCollision: z.ZodObject<{
+    item: z.ZodString;
+    full_path: z.ZodString;
+    methods: z.ZodArray<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+    conflict_owner: z.ZodString;
+    conflict_path: z.ZodString;
+}, z.core.$strip>;
+export type MarketplacePreviewCollision = z.infer<typeof marketplacePreviewCollision>;
+/** One public route the operator is asked to accept: served WITHOUT
+ * authentication once installed. */
+export declare const marketplacePreviewPublicRoute: z.ZodObject<{
+    item: z.ZodString;
+    full_path: z.ZodString;
+    methods: z.ZodArray<z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+}, z.core.$strip>;
+export type MarketplacePreviewPublicRoute = z.infer<typeof marketplacePreviewPublicRoute>;
+/**
+ * The install preview (`POST /api/marketplace/install/preview`): the resolved
+ * routes per item with any base overrides applied, the collisions against the
+ * live registry, the public routes requiring acceptance, and whether acceptance
+ * is required at all. `new_public_routes` narrows to rows not already approved
+ * (the update case); on a fresh install it equals `public_routes`.
+ *
+ * `required_env` is every env var the spec requires with its derived secret-ness;
+ * `missing_env` is the bare names not already present in the env store union
+ * process env (server-computed — the ONE authority the dialog collects), and
+ * `delivery` is the one word the surface shows (`package` / `descriptor`).
+ */
+export declare const marketplaceInstallPreview: z.ZodObject<{
+    ref: z.ZodString;
+    version: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        kind: z.ZodString;
+        base: z.ZodString;
+        default_base: z.ZodString;
+        routes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            full_path: z.ZodString;
+            methods: z.ZodArray<z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            public: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    collisions: z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        full_path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        conflict_owner: z.ZodString;
+        conflict_path: z.ZodString;
+    }, z.core.$strip>>;
+    public_routes: z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        full_path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+    }, z.core.$strip>>;
+    new_public_routes: z.ZodArray<z.ZodObject<{
+        item: z.ZodString;
+        full_path: z.ZodString;
+        methods: z.ZodArray<z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+    }, z.core.$strip>>;
+    requires_public_acceptance: z.ZodBoolean;
+    required_env: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        secret: z.ZodBoolean;
+    }, z.core.$strip>>;
+    missing_env: z.ZodArray<z.ZodString>;
+    delivery: z.ZodEnum<{
+        package: "package";
+        descriptor: "descriptor";
+    }>;
+}, z.core.$strip>;
+export type MarketplaceInstallPreview = z.infer<typeof marketplaceInstallPreview>;
+/**
+ * The receipt of an uninstall. `notes` carries operator warnings (e.g. a config
+ * provider still selected by its env var); render them like the install
+ * receipt's notes.
+ */
+export declare const marketplaceUninstallResult: z.ZodObject<{
+    ref: z.ZodString;
+    uninstalled: z.ZodLiteral<true>;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type MarketplaceUninstallResult = z.infer<typeof marketplaceUninstallResult>;
+//# sourceMappingURL=marketplace.d.ts.map