@kromatv/sdk 0.1.40-canary.0

package/types/client/src/api/events/socket.d.ts

@@ -0,0 +1,42 @@
+import type { CastClientMessage } from '../cast';
+import type { ServerEvent } from './schemas';
+export interface KromaEventsOptions<E extends {
+    type: string;
+} = ServerEvent> {
+    token?: () => string | undefined;
+    refresh?: () => Promise<string | undefined>;
+    onEvent?: (event: E) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    WebSocketImpl?: typeof WebSocket;
+    maxBackoffMs?: number;
+    /** How long to wait before re-checking for the session bearer, which a reload
+     *  does not have until the stored access token has been exchanged. Defaults
+     *  to 150ms. */
+    tokenWaitMs?: number;
+}
+export declare class KromaEvents<E extends {
+    type: string;
+} = ServerEvent> {
+    private readonly url;
+    private readonly opts;
+    private ws;
+    private closed;
+    private retry;
+    private tokenWaits;
+    private refreshSpent;
+    private refreshedToken;
+    private timer;
+    constructor(baseUrl: string, opts?: KromaEventsOptions<E>);
+    /** Returns false when the socket isn't open, so the caller can fall back to
+     * the HTTP path rather than silently dropping the message. */
+    send(message: CastClientMessage): boolean;
+    get open(): boolean;
+    connect(): void;
+    private refreshBearer;
+    private waitForToken;
+    private scheduleReconnect;
+    private get maxBackoff();
+    private after;
+    close(): void;
+}

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

@@ -0,0 +1,68 @@
+import type { RequestContext } from '../../core/client';
+import type { HandoffHandle } from './ids';
+import { type HandoffAnnounce, type HandoffEvidence } from './schemas';
+export default function handoffApi(ctx: RequestContext): {
+    /** Publish this device's beacon: the handle a phone grants against, the
+     * secret to poll with, and how often to poll. Public, since the announcing
+     * device has no account yet. */
+    announce: (body: HandoffAnnounce) => Promise<{
+        handle: string & import("zod").$brand<"HandoffHandle">;
+        secret: string;
+        check: string;
+        confirmRequired: boolean;
+        instanceId: string;
+        proof: string;
+        ttlSecs: number;
+        pollSecs: number;
+    }>;
+    /** Take this beacon down early (signed in another way, or quitting) instead
+     * of lingering until the TTL. */
+    leave: (secret: string) => Promise<void>;
+    /** Poll this beacon by its secret: `pending` until a phone grants it, then
+     * the session exactly once. Polling also keeps the beacon listed, so a TV
+     * that stops polling drops off every phone's list on its own.
+     *
+     * A POST with the secret in the body, not a GET with it in the query: this
+     * is not a read (it refreshes the beacon and consumes the grant), and a URL
+     * is written into every access log the request passes through. */
+    poll: (secret: string) => Promise<{
+        status: "pending";
+    } | {
+        status: "expired";
+    } | {
+        token: string;
+        accessToken: string;
+        user: {
+            id: string & import("zod").$brand<"UserId">;
+            email: string;
+            username: string;
+            avatarUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            audioLanguage?: string | null | undefined;
+            subtitleLanguage?: string | null | undefined;
+            permissions: string[];
+            createdAt: string;
+            hasPin: boolean;
+        };
+        status: "authorized";
+    }>;
+    /** The TVs waiting on this device's own network. Empty off it: the same
+     * answer as "none waiting", which is all a caller may learn. (Bearer.) */
+    devices: () => Promise<{
+        handle: string & import("zod").$brand<"HandoffHandle">;
+        name: string;
+        platform: string;
+        check: string;
+        confirmRequired: boolean;
+    }[]>;
+    /** Hand this account to the TV behind `handle`. Throws `KromaApiError` 400
+     * when a check was required and none was sent, 403 when the check was wrong
+     * and more attempts remain, 429 when they have run out, and 404 when that TV
+     * stopped waiting. (Bearer.) */
+    grant: (handle: HandoffHandle, evidence?: HandoffEvidence) => Promise<void>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        handoff: ReturnType<typeof handoffApi>;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+/** What a phone grants an account against, minted by `POST /handoff/announce`. */
+export declare const HandoffHandle: z.core.$ZodBranded<z.ZodString, "HandoffHandle", "out">;
+export type HandoffHandle = z.infer<typeof HandoffHandle>;

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

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

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

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+/** `POST /handoff/announce`: what a TV waiting for an account gets back.
+ * `secret` never leaves that TV; `handle` is what a phone grants against;
+ * `check` is the five characters the TV prints on its own screen so a person
+ * can tell two TVs apart, and read them out when asked. */
+export declare const HandoffBeacon: z.ZodObject<{
+    handle: z.core.$ZodBranded<z.ZodString, "HandoffHandle", "out">;
+    secret: z.ZodString;
+    check: z.ZodString;
+    confirmRequired: z.ZodDefault<z.ZodBoolean>;
+    instanceId: z.ZodString;
+    proof: z.ZodString;
+    ttlSecs: z.ZodNumber;
+    pollSecs: z.ZodNumber;
+}, z.core.$strip>;
+export type HandoffBeacon = z.infer<typeof HandoffBeacon>;
+/** One TV waiting on the caller's own network (`GET /handoff/devices`). Carries
+ * no address: which TVs are nearby is the point, where they sit is not. */
+export declare const HandoffDevice: z.ZodObject<{
+    handle: z.core.$ZodBranded<z.ZodString, "HandoffHandle", "out">;
+    name: z.ZodString;
+    platform: z.ZodString;
+    check: z.ZodString;
+    confirmRequired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type HandoffDevice = z.infer<typeof HandoffDevice>;
+/** What a TV says about itself when it starts waiting. `deviceId` is its stable
+ * per-install id; re-announcing under it replaces the TV's own row instead of
+ * adding a second. `prevSecret` retires the beacon being replaced up front. */
+export declare const HandoffAnnounce: z.ZodObject<{
+    deviceId: z.core.$ZodBranded<z.ZodString, "DeviceId", "out">;
+    name: z.ZodString;
+    platform: z.ZodString;
+    prevSecret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HandoffAnnounce = z.infer<typeof HandoffAnnounce>;
+/** What a phone sends alongside the handle: why it should be believed to be
+ * beside that television.
+ *
+ * `proof` means this device heard that TV's record on its own link rather than
+ * being told about it by the server, the stronger of the two and the only one
+ * that holds when the addresses cannot be reconciled. `check` is the string the
+ * TV is printing, read off its screen by the person granting; it is demanded of
+ * a beacon the server could not place by its origin, a screen being the one
+ * thing a page pretending to be a television has not got. Case and surrounding
+ * space are the server's to normalise. */
+export declare const HandoffEvidence: z.ZodObject<{
+    proof: z.ZodOptional<z.ZodString>;
+    check: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HandoffEvidence = z.infer<typeof HandoffEvidence>;
+/** The text record a waiting TV publishes: what a phone needs to sign it in.
+ *
+ * `confirmRequired` is deliberately not in here and must never be: anything on
+ * the link can publish one of these, so a record carrying it would let a forged
+ * one wave the confirmation away. */
+export declare const WaitingBeaconTxt: z.ZodObject<{
+    v: z.ZodLiteral<"1">;
+    state: z.ZodLiteral<"waiting">;
+    name: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    server: z.ZodString;
+    handle: z.ZodString;
+    check: z.ZodString;
+    proof: z.ZodString;
+}, z.core.$strip>;
+/** The text record a signed-in TV publishes: enough to recognise it on the cast
+ * roster, and nothing that authorizes anything. */
+export declare const ReadyBeaconTxt: z.ZodObject<{
+    v: z.ZodLiteral<"1">;
+    state: z.ZodLiteral<"ready">;
+    name: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    receiver: z.ZodString;
+}, z.core.$strip>;
+/** Either record, discriminated by the state the TV is in. */
+export declare const BeaconTxt: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    v: z.ZodLiteral<"1">;
+    state: z.ZodLiteral<"waiting">;
+    name: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    server: z.ZodString;
+    handle: z.ZodString;
+    check: z.ZodString;
+    proof: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    v: z.ZodLiteral<"1">;
+    state: z.ZodLiteral<"ready">;
+    name: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    receiver: z.ZodString;
+}, z.core.$strip>], "state">;
+export type BeaconTxt = z.infer<typeof BeaconTxt>;

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

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import type { JobKey, JobRunId } from './ids';
+import { type JobPatch } from './schemas';
+/** The scheduled jobs behind the admin console's Tâches screen. */
+export default function jobsApi(ctx: RequestContext): {
+    list: () => Promise<{
+        jobs: {
+            key: string & z.$brand<"JobKey">;
+            name: string;
+            description: string;
+            category: "acquisition" | "library" | "maintenance" | "pipeline" | "recommendations";
+            schedule: string | null;
+            defaultSchedule: string | null;
+            customized: boolean;
+            enabled: boolean;
+            running: boolean;
+            runId: (string & z.$brand<"JobRunId">) | null;
+            progressDone: number | null;
+            progressTotal: number | null;
+            nextRunAt: number | null;
+            lastRun: {
+                id: string & z.$brand<"JobRunId">;
+                jobKey: string & z.$brand<"JobKey">;
+                trigger: string;
+                status: string;
+                startedAt: number;
+                finishedAt: number | null;
+                durationMs: number | null;
+                progressDone: number | null;
+                progressTotal: number | null;
+                error: string | null;
+            } | null;
+        }[];
+    }>;
+    detail: (key: JobKey) => Promise<{
+        info: {
+            key: string & z.$brand<"JobKey">;
+            name: string;
+            description: string;
+            category: "acquisition" | "library" | "maintenance" | "pipeline" | "recommendations";
+            schedule: string | null;
+            defaultSchedule: string | null;
+            customized: boolean;
+            enabled: boolean;
+            running: boolean;
+            runId: (string & z.$brand<"JobRunId">) | null;
+            progressDone: number | null;
+            progressTotal: number | null;
+            nextRunAt: number | null;
+            lastRun: {
+                id: string & z.$brand<"JobRunId">;
+                jobKey: string & z.$brand<"JobKey">;
+                trigger: string;
+                status: string;
+                startedAt: number;
+                finishedAt: number | null;
+                durationMs: number | null;
+                progressDone: number | null;
+                progressTotal: number | null;
+                error: string | null;
+            } | null;
+        };
+        runs: {
+            id: string & z.$brand<"JobRunId">;
+            jobKey: string & z.$brand<"JobKey">;
+            trigger: string;
+            status: string;
+            startedAt: number;
+            finishedAt: number | null;
+            durationMs: number | null;
+            progressDone: number | null;
+            progressTotal: number | null;
+            error: string | null;
+        }[];
+    }>;
+    run: (key: JobKey) => Promise<{
+        runId: string & z.$brand<"JobRunId">;
+    }>;
+    cancel: (key: JobKey) => Promise<{
+        cancelled: boolean;
+    }>;
+    update: (key: JobKey, patch: JobPatch) => Promise<void>;
+    runLogs: (runId: JobRunId) => Promise<{
+        logs: {
+            ts: number;
+            level: string;
+            message: string;
+        }[];
+    }>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        jobs: ReturnType<typeof jobsApi>;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+/** Which part of the system a scheduled job belongs to. */
+export declare const Category: z.ZodEnum<{
+    acquisition: "acquisition";
+    library: "library";
+    maintenance: "maintenance";
+    pipeline: "pipeline";
+    recommendations: "recommendations";
+}>;
+export type Category = z.infer<typeof Category>;
+/** One recorded execution of a job. */
+export declare const JobRun: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+    jobKey: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+    trigger: z.ZodString;
+    status: z.ZodString;
+    startedAt: z.ZodNumber;
+    finishedAt: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    progressDone: z.ZodNullable<z.ZodNumber>;
+    progressTotal: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type JobRun = z.infer<typeof JobRun>;
+/** A job's definition + current state, as listed in the admin console. */
+export declare const JobInfo: z.ZodObject<{
+    key: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<{
+        acquisition: "acquisition";
+        library: "library";
+        maintenance: "maintenance";
+        pipeline: "pipeline";
+        recommendations: "recommendations";
+    }>;
+    schedule: z.ZodNullable<z.ZodString>;
+    defaultSchedule: z.ZodNullable<z.ZodString>;
+    customized: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+    running: z.ZodBoolean;
+    runId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "JobRunId", "out">>;
+    progressDone: z.ZodNullable<z.ZodNumber>;
+    progressTotal: z.ZodNullable<z.ZodNumber>;
+    nextRunAt: z.ZodNullable<z.ZodNumber>;
+    lastRun: z.ZodNullable<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+        jobKey: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+        trigger: z.ZodString;
+        status: z.ZodString;
+        startedAt: z.ZodNumber;
+        finishedAt: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        progressDone: z.ZodNullable<z.ZodNumber>;
+        progressTotal: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JobInfo = z.infer<typeof JobInfo>;
+/** `PATCH /api/admin/jobs/:key` body. A `null` schedule clears it. */
+export declare const JobPatch: z.ZodObject<{
+    schedule: z.ZodExactOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodExactOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type JobPatch = z.infer<typeof JobPatch>;
+/** One persisted log line of a run. */
+export declare const JobLog: z.ZodObject<{
+    ts: z.ZodNumber;
+    level: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type JobLog = z.infer<typeof JobLog>;
+/** `GET /api/admin/jobs/:key` a job plus its recent run history. */
+export declare const JobDetail: z.ZodObject<{
+    info: z.ZodObject<{
+        key: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+        name: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            acquisition: "acquisition";
+            library: "library";
+            maintenance: "maintenance";
+            pipeline: "pipeline";
+            recommendations: "recommendations";
+        }>;
+        schedule: z.ZodNullable<z.ZodString>;
+        defaultSchedule: z.ZodNullable<z.ZodString>;
+        customized: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        running: z.ZodBoolean;
+        runId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "JobRunId", "out">>;
+        progressDone: z.ZodNullable<z.ZodNumber>;
+        progressTotal: z.ZodNullable<z.ZodNumber>;
+        nextRunAt: z.ZodNullable<z.ZodNumber>;
+        lastRun: z.ZodNullable<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+            jobKey: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+            trigger: z.ZodString;
+            status: z.ZodString;
+            startedAt: z.ZodNumber;
+            finishedAt: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            progressDone: z.ZodNullable<z.ZodNumber>;
+            progressTotal: z.ZodNullable<z.ZodNumber>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+        jobKey: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+        trigger: z.ZodString;
+        status: z.ZodString;
+        startedAt: z.ZodNumber;
+        finishedAt: z.ZodNullable<z.ZodNumber>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        progressDone: z.ZodNullable<z.ZodNumber>;
+        progressTotal: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JobDetail = z.infer<typeof JobDetail>;
+/** What every "start this now" endpoint answers: the run it queued. */
+export declare const JobStarted: z.ZodObject<{
+    runId: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+}, z.core.$strip>;
+export type JobStarted = z.infer<typeof JobStarted>;
+/** What every "stop this" endpoint answers. */
+export declare const JobCancelled: z.ZodObject<{
+    cancelled: z.ZodBoolean;
+}, z.core.$strip>;
+export type JobCancelled = z.infer<typeof JobCancelled>;
+/** `GET /api/admin/jobs`. */
+export declare const JobsView: z.ZodObject<{
+    jobs: z.ZodArray<z.ZodObject<{
+        key: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+        name: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            acquisition: "acquisition";
+            library: "library";
+            maintenance: "maintenance";
+            pipeline: "pipeline";
+            recommendations: "recommendations";
+        }>;
+        schedule: z.ZodNullable<z.ZodString>;
+        defaultSchedule: z.ZodNullable<z.ZodString>;
+        customized: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        running: z.ZodBoolean;
+        runId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "JobRunId", "out">>;
+        progressDone: z.ZodNullable<z.ZodNumber>;
+        progressTotal: z.ZodNullable<z.ZodNumber>;
+        nextRunAt: z.ZodNullable<z.ZodNumber>;
+        lastRun: z.ZodNullable<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "JobRunId", "out">;
+            jobKey: z.core.$ZodBranded<z.ZodString, "JobKey", "out">;
+            trigger: z.ZodString;
+            status: z.ZodString;
+            startedAt: z.ZodNumber;
+            finishedAt: z.ZodNullable<z.ZodNumber>;
+            durationMs: z.ZodNullable<z.ZodNumber>;
+            progressDone: z.ZodNullable<z.ZodNumber>;
+            progressTotal: z.ZodNullable<z.ZodNumber>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type JobsView = z.infer<typeof JobsView>;

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import { LibraryId } from '../media';
+import { type LibraryBody, type LibraryPatch } from './schemas';
+/** Admin library management: folders, scans, and the server-side folder picker. */
+export default function libraryApi(ctx: RequestContext): {
+    /** Libraries with folders, size and item counts (needs an admin capability). */
+    list: () => Promise<{
+        libraries: {
+            id: string & z.$brand<"LibraryId">;
+            name: string;
+            kind: string;
+            folders: string[];
+            itemCount: number;
+            sizeBytes: number;
+            lastScan: string | null;
+            autoScan: boolean;
+        }[];
+    }>;
+    /** Add a library and trigger a rescan (requires `library.manage`). */
+    create: (body: LibraryBody) => Promise<{
+        id: string & z.$brand<"LibraryId">;
+    }>;
+    /** Rename, change folders or toggle auto-scan for a library. */
+    update: (id: LibraryId, patch: LibraryPatch) => Promise<void>;
+    /** Remove a library (its items are dropped on the ensuing rescan). */
+    delete: (id: LibraryId) => Promise<void>;
+    /** Kick a full rescan (from the libraries page). */
+    scan: (id: LibraryId) => Promise<void>;
+    /** Browse server-side directories for the folder picker. An empty or absent
+     * `path` returns the roots (NAS volumes, or `/` in dev). */
+    browse: (path?: string) => Promise<{
+        path: string;
+        parent: string | null;
+        entries: {
+            name: string;
+            path: string;
+        }[];
+    }>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        library: ReturnType<typeof libraryApi>;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './schemas';

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** A named, multi-folder library (`GET /api/admin/libraries`). */
+export declare const AdminLibrary: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "LibraryId", "out">;
+    name: z.ZodString;
+    kind: z.ZodString;
+    folders: z.ZodArray<z.ZodString>;
+    itemCount: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    lastScan: z.ZodNullable<z.ZodString>;
+    autoScan: z.ZodBoolean;
+}, z.core.$strip>;
+export type AdminLibrary = z.infer<typeof AdminLibrary>;
+/** `POST /api/admin/libraries` body. */
+export declare const LibraryBody: z.ZodObject<{
+    name: z.ZodString;
+    folders: z.ZodArray<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LibraryBody = z.infer<typeof LibraryBody>;
+/** `PATCH /api/admin/libraries/:id` body: only the keys present are changed. */
+export declare const LibraryPatch: z.ZodObject<{
+    name: z.ZodExactOptional<z.ZodString>;
+    kind: z.ZodExactOptional<z.ZodString>;
+    folders: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+    autoScan: z.ZodExactOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LibraryPatch = z.infer<typeof LibraryPatch>;

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import { type LlmProbe, type LlmSave } from './schemas';
+/** The LLM provider configuration behind the admin's AI settings. */
+export default function llmApi(ctx: RequestContext): {
+    /** API keys are never returned. */
+    config: () => Promise<{
+        enabled: boolean;
+        defaultId: string;
+        providers: {
+            id: string & z.$brand<"LlmProviderId">;
+            name: string;
+            provider: string;
+            baseUrl: string;
+            model: string;
+            hasApiKey: boolean;
+            temperature: number;
+            maxTokens: number;
+            reasoning: boolean;
+        }[];
+    }>;
+    save: (body: LlmSave) => Promise<void>;
+    models: (probe: LlmProbe) => Promise<{
+        models: string[];
+        error?: string | undefined;
+    }>;
+    /** Never rejects on a bad endpoint: failures come back as `{ ok: false }`. */
+    test: (probe: LlmProbe) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        llm: ReturnType<typeof llmApi>;
+    }
+}

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

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

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

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