/** 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