@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+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>;
+}, z.core.$strip>;
+export type VideoTrack = z.infer<typeof VideoTrack>;
+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;
+}, 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;
+}, 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>;
+    }, 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;
+    }, 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;
+    }, z.core.$strip>>;
+    subtitles: z.ZodArray<z.ZodObject<{
+        language: z.ZodNullable<z.ZodString>;
+        codec: z.ZodString;
+    }, 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. */
+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>;
+    }, 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;
+    }, 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;
+    }, z.core.$strip>>;
+    subtitles: z.ZodArray<z.ZodObject<{
+        language: z.ZodNullable<z.ZodString>;
+        codec: z.ZodString;
+    }, 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;
+}, z.core.$strip>;
+export type MediaFile = z.infer<typeof MediaFile>;
+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,226 @@
+import { z } from 'zod';
+/** 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;
+    compatible: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    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;
+        compatible: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        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>;

package/types/client/src/api/notifications/capability.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { KromaClient } from '../../kroma-client';
+import type { SubscribeBody } from './schemas';
+/** Why push cannot work on this device, or `null` when it can. One vocabulary
+ * across every client, so the settings screen gives the same explanation on the
+ * web app and the phone. */
+export declare const PushBlocker: z.ZodEnum<{
+    denied: "denied";
+    insecure: "insecure";
+    "needs-install": "needs-install";
+    "needs-rebuild": "needs-rebuild";
+    simulator: "simulator";
+    unsupported: "unsupported";
+}>;
+export type PushBlocker = z.infer<typeof PushBlocker>;
+/** What {@link PushCapability.subscribe} is given by the shared layer. */
+export interface PushSubscribeContext {
+    applicationServerKey: string;
+}
+/** The per-platform half: reaching this device's push system. Implementations
+ * do no orchestration and talk to no API; throwing a {@link PushBlocker} as the
+ * error message from `subscribe` is how a platform reports a refusal it could
+ * only discover by trying. */
+export interface PushCapability {
+    blocker(): Promise<PushBlocker | null>;
+    subscribe(context: PushSubscribeContext): Promise<SubscribeBody>;
+    endpoint(): Promise<string | null>;
+    unsubscribe(): Promise<void>;
+}
+/** Turn push on for this device. Throws with a {@link PushBlocker} as the
+ * message, so a caller can look the reason up in its own translations. */
+export declare function enablePush(capability: PushCapability, client: KromaClient): Promise<void>;
+/** Turn push off for this device, both sides. The platform subscription goes
+ * first: if the server call then fails, the device is already silent instead of
+ * one the user believes is off but which still buzzes. */
+export declare function disablePush(capability: PushCapability, client: KromaClient): Promise<void>;

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import type { NotificationId } from './ids';
+import { type NotificationAction, NotificationPrefs } from './schemas';
+/** The notification centre. Every call is scoped to the signed-in account: the
+ * server takes the user from the session and ignores any id that says otherwise. */
+export default function notificationsApi(ctx: RequestContext): {
+    push: {
+        key: () => Promise<{
+            publicKey: string;
+            subscribed: boolean;
+        }>;
+        subscribe: (body: import("./schemas").SubscribeBody) => Promise<void>;
+        unsubscribe: (endpoint: string) => Promise<void>;
+        test: () => Promise<{
+            delivered: number;
+        }>;
+    };
+    /** Newest first, with the unread tally. */
+    list: () => Promise<{
+        notifications: {
+            id: string & z.$brand<"NotificationId">;
+            category: "downloads" | "media" | "reports" | "requests" | "system";
+            event: string;
+            title: string;
+            body: string;
+            link?: string | undefined;
+            imageUrl?: string | undefined;
+            actions: {
+                id: string;
+                label: string;
+                kind: "api" | "link";
+                href: string;
+                method?: string | undefined;
+                style: "danger" | "default" | "primary";
+            }[];
+            read: boolean;
+            createdAt: number;
+        }[];
+        unread: number;
+    }>;
+    markRead: (ids: NotificationId[]) => Promise<{
+        unread: number;
+    }>;
+    /** Put rows back in the unread pile. There is no "all" here on purpose: the
+     * affordance is per-row, and nobody wants a whole inbox back. */
+    markUnread: (ids: NotificationId[]) => Promise<{
+        unread: number;
+    }>;
+    /** Omitting `ids` is what the server reads as "all". */
+    markAllRead: () => Promise<{
+        unread: number;
+    }>;
+    delete: (id: NotificationId) => Promise<void>;
+    /** The full per-category delivery matrix, defaults filled in. */
+    prefs: () => Promise<{
+        categories: {
+            category: "downloads" | "media" | "reports" | "requests" | "system";
+            inApp: boolean;
+            push: boolean;
+        }[];
+    }>;
+    setPrefs: (prefs: NotificationPrefs) => Promise<{
+        categories: {
+            category: "downloads" | "media" | "reports" | "requests" | "system";
+            inApp: boolean;
+            push: boolean;
+        }[];
+    }>;
+    /** Run a notification's `api` action (approve or deny straight from the row).
+     * `href` is already API-absolute, so the `/api` the transport adds back is
+     * stripped first. */
+    runAction: (action: Pick<NotificationAction, 'href' | 'method'>) => Promise<void>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        notifications: ReturnType<typeof notificationsApi>;
+    }
+}

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

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

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

@@ -0,0 +1,4 @@
+export * from './capability';
+export * from './client';
+export * from './ids';
+export * from './schemas';

package/types/client/src/api/notifications/push.d.ts

@@ -0,0 +1,18 @@
+import type { RequestContext } from '../../core/http';
+import type { SubscribeBody } from './schemas';
+/** Web Push and the native transports, from this device's side. */
+export declare function pushApi(ctx: RequestContext): {
+    /** The server's VAPID public key (`applicationServerKey`); the keypair is
+     * minted on the first call. */
+    key: () => Promise<{
+        publicKey: string;
+        subscribed: boolean;
+    }>;
+    /** Re-registering the same endpoint updates it rather than duplicating, and
+     * moves it to the calling account. */
+    subscribe: (body: SubscribeBody) => Promise<void>;
+    unsubscribe: (endpoint: string) => Promise<void>;
+    test: () => Promise<{
+        delivered: number;
+    }>;
+};