@kromatv/sdk 0.1.39-canary.3579809

package/types/client/src/api/media/tracks.d.ts

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+/** The HDR system a stream carries. Each has its own client support, so a device
+ * that renders HDR10 and one that also renders Dolby Vision are not the same
+ * device. */
+export declare const HdrFormat: z.ZodEnum<{
+    dolbyVision: "dolbyVision";
+    hdr10: "hdr10";
+    hdr10Plus: "hdr10Plus";
+    hlg: "hlg";
+}>;
+export type HdrFormat = z.infer<typeof HdrFormat>;
+/** Colour signalling in the container's own spelling (`bt2020`, `smpte2084`,
+ * `bt709`, ...), which is what a client is matched against. */
+export declare const ColorInfo: z.ZodObject<{
+    primaries: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    transfer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    matrix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ColorInfo = z.infer<typeof ColorInfo>;
+/** `hdr` is what a client that predates `hdrFormat` reads: true for any variant,
+ * and still true where the variant itself was never recorded, so `hdr` without
+ * `hdrFormat` means "HDR, variant unknown" and never SDR. */
+export declare const VideoTrack: z.ZodObject<{
+    codec: z.ZodString;
+    width: z.ZodNullable<z.ZodNumber>;
+    height: z.ZodNullable<z.ZodNumber>;
+    hdr: z.ZodBoolean;
+    bitDepth: z.ZodNullable<z.ZodNumber>;
+    hdrFormat: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        dolbyVision: "dolbyVision";
+        hdr10: "hdr10";
+        hdr10Plus: "hdr10Plus";
+        hlg: "hlg";
+    }>>>;
+    dolbyVisionProfile: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    color: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        primaries: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        transfer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        matrix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type VideoTrack = z.infer<typeof VideoTrack>;
+/** One audio track. `region` is the dub's region when the file says which
+ * (`CA` for a Québec dub, `FR` for a France one), from its tag or its title. */
+export declare const AudioTrack: z.ZodObject<{
+    index: z.ZodNumber;
+    codec: z.ZodString;
+    channels: z.ZodNullable<z.ZodNumber>;
+    language: z.ZodNullable<z.ZodString>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    default: z.ZodBoolean;
+    region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type AudioTrack = z.infer<typeof AudioTrack>;
+export declare const AudioVerdict: z.ZodEnum<{
+    highDynamics: "highDynamics";
+    ok: "ok";
+    quietDialog: "quietDialog";
+}>;
+export type AudioVerdict = z.infer<typeof AudioVerdict>;
+/** EBU R128 loudness measurement of an item's default audio track: `lufsI` and
+ * `dialogLufs` in LUFS, `lra` in LU, `truePeak` in dBTP. */
+export declare const AudioAnalysis: z.ZodObject<{
+    lufsI: z.ZodNumber;
+    lra: z.ZodNumber;
+    truePeak: z.ZodNumber;
+    dialogLufs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    verdict: z.ZodEnum<{
+        highDynamics: "highDynamics";
+        ok: "ok";
+        quietDialog: "quietDialog";
+    }>;
+}, z.core.$strip>;
+export type AudioAnalysis = z.infer<typeof AudioAnalysis>;
+export declare const SubtitleTrack: z.ZodObject<{
+    language: z.ZodNullable<z.ZodString>;
+    codec: z.ZodString;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    forced: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SubtitleTrack = z.infer<typeof SubtitleTrack>;
+/** What both a logical item and one of its files carry about the bytes on disk. */
+export declare const Tracks: z.ZodObject<{
+    container: z.ZodString;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    relPath: z.ZodNullable<z.ZodString>;
+    video: z.ZodNullable<z.ZodObject<{
+        codec: z.ZodString;
+        width: z.ZodNullable<z.ZodNumber>;
+        height: z.ZodNullable<z.ZodNumber>;
+        hdr: z.ZodBoolean;
+        bitDepth: z.ZodNullable<z.ZodNumber>;
+        hdrFormat: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            dolbyVision: "dolbyVision";
+            hdr10: "hdr10";
+            hdr10Plus: "hdr10Plus";
+            hlg: "hlg";
+        }>>>;
+        dolbyVisionProfile: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        color: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            primaries: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            transfer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            matrix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    audio: z.ZodNullable<z.ZodObject<{
+        index: z.ZodNumber;
+        codec: z.ZodString;
+        channels: z.ZodNullable<z.ZodNumber>;
+        language: z.ZodNullable<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodBoolean;
+        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    audioTracks: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        codec: z.ZodString;
+        channels: z.ZodNullable<z.ZodNumber>;
+        language: z.ZodNullable<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodBoolean;
+        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    subtitles: z.ZodArray<z.ZodObject<{
+        language: z.ZodNullable<z.ZodString>;
+        codec: z.ZodString;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        forced: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One physical file backing a logical [`MediaItem`]. `id` is a `short_hash` of
+ * the absolute path, not a media-item id. `unreadable` carries ffprobe's reason
+ * the container would not open, which is not the same as `probed: false`: one is
+ * a broken file, the other is a file nothing has looked at yet. */
+export declare const MediaFile: z.ZodObject<{
+    container: z.ZodString;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    relPath: z.ZodNullable<z.ZodString>;
+    video: z.ZodNullable<z.ZodObject<{
+        codec: z.ZodString;
+        width: z.ZodNullable<z.ZodNumber>;
+        height: z.ZodNullable<z.ZodNumber>;
+        hdr: z.ZodBoolean;
+        bitDepth: z.ZodNullable<z.ZodNumber>;
+        hdrFormat: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            dolbyVision: "dolbyVision";
+            hdr10: "hdr10";
+            hdr10Plus: "hdr10Plus";
+            hlg: "hlg";
+        }>>>;
+        dolbyVisionProfile: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        color: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            primaries: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            transfer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            matrix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    audio: z.ZodNullable<z.ZodObject<{
+        index: z.ZodNumber;
+        codec: z.ZodString;
+        channels: z.ZodNullable<z.ZodNumber>;
+        language: z.ZodNullable<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodBoolean;
+        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    audioTracks: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        codec: z.ZodString;
+        channels: z.ZodNullable<z.ZodNumber>;
+        language: z.ZodNullable<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodBoolean;
+        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    subtitles: z.ZodArray<z.ZodObject<{
+        language: z.ZodNullable<z.ZodString>;
+        codec: z.ZodString;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        forced: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    id: z.core.$ZodBranded<z.ZodString, "MediaFileId", "out">;
+    size: z.ZodNullable<z.ZodNumber>;
+    edition: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    probed: z.ZodBoolean;
+    unreadable: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    editionId: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "EditionId", "out">>>;
+}, z.core.$strip>;
+export type MediaFile = z.infer<typeof MediaFile>;
+/** One named cut of a title: its own runtime, its own content. Two files of one
+ * cut at different fidelities are two media files of THIS, never two editions.
+ * `name` is absent for the one unnamed edition a single-cut title has. */
+export declare const Edition: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "EditionId", "out">;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type Edition = z.infer<typeof Edition>;
+export declare const MarkerKind: z.ZodEnum<{
+    credits: "credits";
+    intro: "intro";
+}>;
+export type MarkerKind = z.infer<typeof MarkerKind>;
+export declare const Marker: z.ZodObject<{
+    kind: z.ZodEnum<{
+        credits: "credits";
+        intro: "intro";
+    }>;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+}, z.core.$strip>;
+export type Marker = z.infer<typeof Marker>;
+/** Server-side loudness-filter variant of the HLS master (night-mode volume
+ * leveling for engines with no local audio DSP, e.g. Tizen AVPlay). The names
+ * match the client Web Audio compressor modes; either one forces the AAC
+ * transcode (a stream copy cannot be filtered), superseding `aac`. */
+export declare const HlsAudioFilter: z.ZodEnum<{
+    night: "night";
+    standard: "standard";
+}>;
+export type HlsAudioFilter = z.infer<typeof HlsAudioFilter>;
+/** Scrub-bar preview "storyboard": one sprite sheet of evenly-spaced thumbnails
+ * plus the geometry needed to map a cursor time → a tile (YouTube-style hover
+ * preview). Generated once per file by the server and cached on disk. */
+export declare const StoryboardManifest: z.ZodObject<{
+    url: z.ZodString;
+    interval: z.ZodNumber;
+    tileW: z.ZodNumber;
+    tileH: z.ZodNumber;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    count: z.ZodNumber;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export type StoryboardManifest = z.infer<typeof StoryboardManifest>;

package/types/client/src/api/modules/client.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import type { ModuleId } from './ids';
+/** The module registry, and the door to one module's own admin API. */
+export default function modulesApi(ctx: RequestContext): {
+    /** Modules on this server with their enabled flag + capabilities; drives the
+     * admin console's data-driven ADD flows. */
+    list: () => Promise<{
+        id: string & z.$brand<"ModuleId">;
+        name: string;
+        enabled?: boolean | undefined;
+        contributes?: {
+            point: string;
+            id?: string | undefined;
+            label?: string | undefined;
+            fields?: {
+                key: string;
+                label: string;
+                type: "bool" | "number" | "select" | "string";
+                default?: string | undefined;
+                options?: string[] | undefined;
+                placeholder?: string | undefined;
+                secret?: boolean | undefined;
+                required?: boolean | undefined;
+            }[] | undefined;
+            flow?: string | undefined;
+        }[] | undefined;
+    }[]>;
+    /** The admin API of one module, addressed by its id. A module's routes are
+     * its own: they live under `/api/admin/m/<id>`, so they are not part of this
+     * facade and cannot collide with a core route. */
+    api: (id: ModuleId) => import("./module-api").ModuleApi;
+};
+declare module '../../core/client' {
+    interface Domains {
+        modules: ReturnType<typeof modulesApi>;
+    }
+}

package/types/client/src/api/modules/ids.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+export declare const ModuleId: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+export type ModuleId = z.infer<typeof ModuleId>;

package/types/client/src/api/modules/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './ids';
+export * from './module-api';
+export * from './schemas';
+export * from './store';

package/types/client/src/api/modules/module-api.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { RequestContext } from '../../core/http';
+import type { ModuleId } from './ids';
+/** The request surface a module gets for its own admin routes. Paths are
+ *  relative to the module's mount: `get('/clients', Clients)` reads
+ *  `/api/admin/m/<id>/clients` and parses it.
+ *
+ *  A module owns the shape of its own API and ships on its own tag, so the core
+ *  cannot hold its schemas: the module passes them in, and the parse happens at
+ *  the same boundary and with the same errors as every core call. */
+export interface ModuleApi {
+    get<S extends z.ZodType>(path: string, response: S): Promise<z.output<S>>;
+    post<S extends z.ZodType>(path: string, body: unknown, response: S): Promise<z.output<S>>;
+    post(path: string, body?: unknown): Promise<void>;
+    put<S extends z.ZodType>(path: string, body: unknown, response: S): Promise<z.output<S>>;
+    put(path: string, body?: unknown): Promise<void>;
+    delete<S extends z.ZodType>(path: string, response: S): Promise<z.output<S>>;
+    delete(path: string): Promise<void>;
+    /** Raw bytes rather than JSON, for a file a module accepts directly. */
+    upload<S extends z.ZodType>(path: string, file: Blob, response: S, headers?: Record<string, string>): Promise<z.output<S>>;
+}
+/** Bind `ctx` to the admin mount of module `id`. */
+export declare function moduleApi(ctx: RequestContext, id: ModuleId): ModuleApi;

package/types/client/src/api/modules/schemas.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+/** One field in an engine's add-form (mirrors the Rust `ConfigField`, whose
+ * `type` is a free string: a kind this build does not know renders as text). */
+export declare const EngineField: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodCatch<z.ZodEnum<{
+        bool: "bool";
+        number: "number";
+        select: "select";
+        string: "string";
+    }>>;
+    default: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EngineField = z.infer<typeof EngineField>;
+/** One thing a module contributes: it answers `point`, under `id` when several
+ * contributions to that point can be live at once. A contribution with an
+ * add-flow also carries a display `label` plus either `fields` (a plain form) or
+ * a custom `flow` discriminator the host page renders itself. */
+export declare const EngineContribution: z.ZodObject<{
+    point: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodCatch<z.ZodEnum<{
+            bool: "bool";
+            number: "number";
+            select: "select";
+            string: "string";
+        }>>;
+        default: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        secret: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    flow: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EngineContribution = z.infer<typeof EngineContribution>;
+/** One module from `GET /api/modules`: its manifest identity, admin `enabled`
+ * flag (default true), and the points it answers. */
+export declare const ModuleInfo: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    name: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    contributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodCatch<z.ZodEnum<{
+                bool: "bool";
+                number: "number";
+                select: "select";
+                string: "string";
+            }>>;
+            default: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        flow: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ModuleInfo = z.infer<typeof ModuleInfo>;

package/types/client/src/api/modules/store.d.ts

@@ -0,0 +1,278 @@
+import { z } from 'zod';
+/** Why this server cannot take a catalog entry, for the client to word. */
+export declare const StoreRefusal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"schema">;
+    built: z.ZodNumber;
+    speaks: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknownEngine">;
+    engine: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"engine">;
+    engine: z.ZodString;
+    range: z.ZodString;
+    serverVersion: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"platform">;
+    target: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type StoreRefusal = z.infer<typeof StoreRefusal>;
+/** One catalog entry, enriched server-side (`GET /api/admin/store/catalog`):
+ * the picked artifact for this platform, installed/update state, and the
+ * compatibility verdict with its reason. */
+export declare const StoreModule: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    library: z.ZodBoolean;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    engines: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dependencies: z.ZodRecord<z.ZodString, z.ZodString>;
+    optionalDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
+    contributes: z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>;
+    consumes: z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    sha256: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    installedVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updateAvailable: z.ZodBoolean;
+    updateBlocked: z.ZodDefault<z.ZodBoolean>;
+    compatible: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    refusal: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        built: z.ZodNumber;
+        speaks: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknownEngine">;
+        engine: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"engine">;
+        engine: z.ZodString;
+        range: z.ZodString;
+        serverVersion: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"platform">;
+        target: z.ZodString;
+    }, z.core.$strip>], "kind">>>>;
+    source: z.ZodString;
+}, z.core.$strip>;
+export type StoreModule = z.infer<typeof StoreModule>;
+/** One registry row: the stored entry merged with its fetch outcome (`skipped`
+ * carries why a row was not consulted; `shadowed` the ids a higher-priority
+ * registry already claimed). */
+export declare const StoreRegistry: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    official: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+    skipped: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    moduleCount: z.ZodNumber;
+    shadowed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type StoreRegistry = z.infer<typeof StoreRegistry>;
+/** `GET /api/admin/store/catalog`, merged across every configured registry.
+ * `registryUrl` and the top-level `error` describe the OFFICIAL registry only
+ * (legacy shape); `registries` carries every row. */
+export declare const StoreCatalog: z.ZodObject<{
+    schema: z.ZodNumber;
+    serverVersion: z.ZodString;
+    target: z.ZodString;
+    registryUrl: z.ZodString;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    registries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        official: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        skipped: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        moduleCount: z.ZodNumber;
+        shadowed: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodString;
+        library: z.ZodBoolean;
+        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        engines: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        dependencies: z.ZodRecord<z.ZodString, z.ZodString>;
+        optionalDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
+        contributes: z.ZodArray<z.ZodObject<{
+            point: z.ZodString;
+            version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>;
+        consumes: z.ZodArray<z.ZodObject<{
+            point: z.ZodString;
+            version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            optional: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$catchall<z.ZodJSONSchema>>>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        sha256: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        installedVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updateAvailable: z.ZodBoolean;
+        updateBlocked: z.ZodDefault<z.ZodBoolean>;
+        compatible: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        refusal: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            built: z.ZodNumber;
+            speaks: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknownEngine">;
+            engine: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"engine">;
+            engine: z.ZodString;
+            range: z.ZodString;
+            serverVersion: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"platform">;
+            target: z.ZodString;
+        }, z.core.$strip>], "kind">>>>;
+        source: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoreCatalog = z.infer<typeof StoreCatalog>;
+/** One resolved row of an install plan, dependencies first. `requested` is
+ * false for a module that rides along as a dependency. */
+export declare const StorePlanModule: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    name: z.ZodString;
+    version: z.ZodString;
+    size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    installedVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    requested: z.ZodBoolean;
+}, z.core.$strip>;
+export type StorePlanModule = z.infer<typeof StorePlanModule>;
+/** A compatible, not-yet-installed opt-in the install dialog offers: a
+ * declared optional dependency (`point` null), or a contributor to a point the
+ * plan `consumes` and nothing answers (`point` = the one it would answer).
+ * `for` names the module asking. */
+export declare const StoreOptionalModule: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    name: z.ZodString;
+    version: z.ZodString;
+    size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    point: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    for: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    suggested: z.ZodBoolean;
+}, z.core.$strip>;
+export type StoreOptionalModule = z.infer<typeof StoreOptionalModule>;
+/** A point no installed, planned or available module answers. */
+export declare const StoreMissingPoint: z.ZodObject<{
+    point: z.ZodString;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    for: z.ZodString;
+}, z.core.$strip>;
+export type StoreMissingPoint = z.infer<typeof StoreMissingPoint>;
+/** `POST /api/admin/store/plan`: the dry-run behind the install dialog. */
+export declare const StorePlan: z.ZodObject<{
+    requested: z.ZodString;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+        name: z.ZodString;
+        version: z.ZodString;
+        size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        installedVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        requested: z.ZodBoolean;
+    }, z.core.$strip>>;
+    optional: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+        name: z.ZodString;
+        version: z.ZodString;
+        size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        point: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        for: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        suggested: z.ZodBoolean;
+    }, z.core.$strip>>;
+    missing: z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        for: z.ZodString;
+    }, z.core.$strip>>;
+    totalSize: z.ZodNumber;
+}, z.core.$strip>;
+export type StorePlan = z.infer<typeof StorePlan>;
+/** `POST /api/admin/store/install-id`: everything actually installed, deps
+ * included, in install order. `op` names the `module.op.*` stream that carried
+ * this operation's progress. */
+export declare const StoreInstallReport: z.ZodObject<{
+    op: z.ZodString;
+    requested: z.ZodString;
+    installed: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoreInstallReport = z.infer<typeof StoreInstallReport>;
+/** `POST /api/admin/store/update`: the batch update outcome. */
+export declare const StoreUpdateResult: z.ZodObject<{
+    updated: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+    failed: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoreUpdateResult = z.infer<typeof StoreUpdateResult>;
+/** `POST /api/admin/store/registry-preview`: what a candidate registry URL
+ * serves, fetched before the row is saved. */
+export declare const StoreRegistryPreview: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    moduleCount: z.ZodNumber;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        library: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoreRegistryPreview = z.infer<typeof StoreRegistryPreview>;
+/** `POST /api/admin/modules/{id}/enabled`. `warning` reports a sidecar that
+ * failed to start; the flag is set either way, the admin asked for it. */
+export declare const ModuleEnabledResult: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    enabled: z.ZodBoolean;
+    warning: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ModuleEnabledResult = z.infer<typeof ModuleEnabledResult>;
+/** `POST /api/admin/modules/{id}/restart`. `running` is what the supervisor
+ * reports once the process is back up. */
+export declare const ModuleRestartResult: z.ZodObject<{
+    restarted: z.ZodBoolean;
+    running: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModuleRestartResult = z.infer<typeof ModuleRestartResult>;
+/** The structured `409 Conflict` body of `DELETE /api/admin/store/{id}`: who
+ * still depends on the module, so the UI can offer an informed force. */
+export declare const StoreUninstallConflict: z.ZodObject<{
+    error: z.ZodString;
+    dependents: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type StoreUninstallConflict = z.infer<typeof StoreUninstallConflict>;