@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,214 @@
+import { z } from 'zod';
+/** The known capability keys (mirror of the Rust `Permission` enum). */
+export declare const Permission: z.ZodEnum<{
+    "library.manage": "library.manage";
+    playback: "playback";
+    "reports.manage": "reports.manage";
+    "requests.auto": "requests.auto";
+    "requests.create": "requests.create";
+    "requests.manage": "requests.manage";
+    "settings.manage": "settings.manage";
+    "users.manage": "users.manage";
+}>;
+export type Permission = z.infer<typeof Permission>;
+/** A full account (`GET /auth/me`, login/exchange results). `permissions` is
+ * validated as `string[]`, not the closed {@link Permission} enum: this runs in
+ * the auth-critical login/exchange path, so a server that adds a capability must
+ * not make an older client throw on an unknown key. */
+export declare const User: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "UserId", "out">;
+    email: z.ZodString;
+    username: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    audioLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    subtitleLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    permissions: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    hasPin: z.ZodBoolean;
+}, z.core.$strip>;
+export type User = z.infer<typeof User>;
+/** True if the user holds `permission`. Tolerates a missing `permissions` array
+ * so a session persisted by an older client (before capabilities existed)
+ * degrades to "no permissions" instead of crashing. */
+export declare function hasPermission(user: Pick<User, 'permissions'>, permission: Permission): boolean;
+/** The public (no-email) profile in the picker roster. */
+export declare const PublicUser: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "UserId", "out">;
+    username: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hasPin: z.ZodBoolean;
+}, z.core.$strip>;
+export type PublicUser = z.infer<typeof PublicUser>;
+/** Public login-gate config. */
+export declare const AuthConfig: z.ZodObject<{
+    publicUserList: z.ZodBoolean;
+    hasAccounts: z.ZodBoolean;
+}, z.core.$strip>;
+export type AuthConfig = z.infer<typeof AuthConfig>;
+/** `{ token, accessToken, user }` from register/login. */
+export declare const AuthResult: z.ZodObject<{
+    token: z.ZodString;
+    accessToken: z.ZodString;
+    user: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "UserId", "out">;
+        email: z.ZodString;
+        username: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        audioLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        subtitleLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        permissions: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        hasPin: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AuthResult = z.infer<typeof AuthResult>;
+/** `{ token, user }` from `/auth/token` (session refresh/exchange). */
+export declare const SessionResult: z.ZodObject<{
+    token: z.ZodString;
+    user: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "UserId", "out">;
+        email: z.ZodString;
+        username: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        audioLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        subtitleLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        permissions: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        hasPin: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SessionResult = z.infer<typeof SessionResult>;
+/** One signed-in device from `GET /auth/me/sessions`. `id` is a non-secret
+ * handle used to revoke it; `current` marks the device making the request. */
+export declare const SessionInfo: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "SessionId", "out">;
+    userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    lastSeen: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    current: z.ZodBoolean;
+}, z.core.$strip>;
+export type SessionInfo = z.infer<typeof SessionInfo>;
+/** One registered passkey from `GET /auth/me/passkeys`. `id` revokes it. */
+export declare const PasskeyInfo: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "PasskeyId", "out">;
+    name: z.ZodString;
+    createdAt: z.ZodString;
+    lastUsed: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type PasskeyInfo = z.infer<typeof PasskeyInfo>;
+/** `POST /auth/quickconnect/initiate` a device-pairing request. */
+export declare const QuickConnectInit: z.ZodObject<{
+    code: z.ZodString;
+    secret: z.ZodString;
+    expiresInSec: z.ZodNumber;
+    authorizeUrl: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type QuickConnectInit = z.infer<typeof QuickConnectInit>;
+/** The status-tagged union both pairing polls answer with
+ * (`/auth/quickconnect/poll`, `/handoff/poll`). `expired` covers an unknown
+ * secret too: a device that cannot tell them apart simply starts over. */
+export declare const PairingStatus: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"pending">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"expired">;
+}, z.core.$strip>, z.ZodObject<{
+    token: z.ZodString;
+    accessToken: z.ZodString;
+    user: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "UserId", "out">;
+        email: z.ZodString;
+        username: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        audioLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        subtitleLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        permissions: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        hasPin: z.ZodBoolean;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"authorized">;
+}, z.core.$strip>], "status">;
+export type PairingStatus = z.infer<typeof PairingStatus>;
+/** `POST /api/admin/users/:id/reset` the link plus the one-time code the owner
+ * reads to the user. */
+export declare const ResetCreated: z.ZodObject<{
+    token: z.ZodString;
+    code: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNumber;
+    delivered: z.ZodCatch<z.ZodEnum<{
+        manual: "manual";
+        smtp: "smtp";
+    }>>;
+}, z.core.$strip>;
+export type ResetCreated = z.infer<typeof ResetCreated>;
+/** `POST /api/admin/users/:id/email-verification` the verification link. No
+ * code: reaching the mailbox is itself the proof. */
+export declare const VerificationCreated: z.ZodObject<{
+    token: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNumber;
+    delivered: z.ZodCatch<z.ZodEnum<{
+        manual: "manual";
+        smtp: "smtp";
+    }>>;
+}, z.core.$strip>;
+export type VerificationCreated = z.infer<typeof VerificationCreated>;
+/** `GET /api/auth/reset/:token` the public check before the reset form.
+ * Reused by `/api/auth/verify-email/:token`, same shape. */
+export declare const ResetCheck: z.ZodObject<{
+    valid: z.ZodBoolean;
+    username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ResetCheck = z.infer<typeof ResetCheck>;
+/** A registration invitation created by a user with `users.manage`. `createdBy`
+ * is a nullable display string, not a branded id. */
+export declare const Invite: z.ZodObject<{
+    token: z.core.$ZodBranded<z.ZodString, "InviteToken", "out">;
+    permissions: z.ZodArray<z.ZodEnum<{
+        "library.manage": "library.manage";
+        playback: "playback";
+        "reports.manage": "reports.manage";
+        "requests.auto": "requests.auto";
+        "requests.create": "requests.create";
+        "requests.manage": "requests.manage";
+        "settings.manage": "settings.manage";
+        "users.manage": "users.manage";
+    }>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodNumber;
+    used: z.ZodBoolean;
+}, z.core.$strip>;
+export type Invite = z.infer<typeof Invite>;
+/** `POST /api/invites` result the invite plus a ready-to-share join URL. */
+export declare const InviteCreated: z.ZodObject<{
+    token: z.core.$ZodBranded<z.ZodString, "InviteToken", "out">;
+    permissions: z.ZodArray<z.ZodEnum<{
+        "library.manage": "library.manage";
+        playback: "playback";
+        "reports.manage": "reports.manage";
+        "requests.auto": "requests.auto";
+        "requests.create": "requests.create";
+        "requests.manage": "requests.manage";
+        "settings.manage": "settings.manage";
+        "users.manage": "users.manage";
+    }>>;
+    expiresAt: z.ZodNumber;
+    url: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type InviteCreated = z.infer<typeof InviteCreated>;
+/** A patch of the signed-in account's own profile. Omitted keys are left
+ * unchanged; a `null` clears the field (only the language prefs are clearable
+ * server-side, username and email must be non-empty). */
+export declare const AccountPatch: z.ZodObject<{
+    email: z.ZodExactOptional<z.ZodString>;
+    username: z.ZodExactOptional<z.ZodString>;
+    language: z.ZodExactOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    audioLanguage: z.ZodExactOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    subtitleLanguage: z.ZodExactOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+}, z.core.$strip>;
+export type AccountPatch = z.infer<typeof AccountPatch>;

package/types/client/src/api/admin/backup.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/http';
+export declare const BackupImportResult: z.ZodObject<{
+    imported: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    rescanStarted: z.ZodBoolean;
+}, z.core.$strip>;
+export type BackupImportResult = z.infer<typeof BackupImportResult>;
+export interface BackupImportOptions {
+    password?: string;
+    reset?: boolean;
+}
+/** Portable backup: take one out, put one back. Requires `settings.manage`. */
+export declare function backupApi(ctx: RequestContext): {
+    /** A `password` encrypts the archive (`.kroma`), else it is a plain `.zip`. */
+    export: (password?: string) => Promise<Blob>;
+    /** Restores a `.zip`/`.kroma`/legacy `.json`, then triggers a re-scan so the
+     * catalogue regenerates with matching item ids. */
+    import: (file: Blob, opts?: BackupImportOptions) => Promise<{
+        imported: Record<string, number>;
+        rescanStarted: boolean;
+    }>;
+};

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

@@ -0,0 +1,407 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import { type UserId } from '../accounts';
+import type { PlaybackSessionId } from '../playback';
+import { type MetricRange } from './metrics';
+import { type AdminUserPatch } from './users';
+interface HistoryWindow {
+    days?: number;
+    kind?: string;
+    user?: UserId;
+}
+/** The admin console: server identity, live sessions, metrics and storage,
+ * accounts, settings, and the watch statistics behind the dashboard. */
+export default function adminApi(ctx: RequestContext): {
+    backup: {
+        export: (password?: string) => Promise<Blob>;
+        import: (file: Blob, opts?: import("./backup").BackupImportOptions) => Promise<{
+            imported: Record<string, number>;
+            rescanStarted: boolean;
+        }>;
+    };
+    notifications: {
+        samples: () => Promise<{
+            events: {
+                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;
+            }[];
+        }>;
+        send: (body: import("../notifications").SendNotificationBody) => Promise<{
+            delivered: number;
+        }>;
+        uploadImage: (file: Blob) => Promise<{
+            imageUrl: string;
+        }>;
+        images: () => Promise<{
+            images: {
+                name: string;
+                url: string;
+                uploadedAt: number;
+                bytes: number;
+            }[];
+        }>;
+    };
+    server: () => Promise<{
+        name: string;
+        hostname: string;
+        version: string;
+        uptimeSec: number;
+        online: boolean;
+        sessions: number;
+    }>;
+    /** Live scan / enrichment status snapshot. */
+    status: () => Promise<{
+        phase: string;
+        scanning: boolean;
+        libraries: number;
+        shows: number;
+        items: number;
+        enrichDone: number;
+        enrichTotal: number;
+        probeDone: number;
+        probeTotal: number;
+        lastScanAt: string | null;
+    }>;
+    sessions: () => Promise<{
+        sessions: {
+            id: string & z.$brand<"PlaybackSessionId">;
+            userId?: (string & z.$brand<"UserId">) | null | undefined;
+            username: string;
+            itemId: string & z.$brand<"ItemId">;
+            title: string;
+            year: number | null;
+            kind: string;
+            showTitle?: string | null | undefined;
+            season: number | null;
+            episode: number | null;
+            videoLabel: string;
+            audioLabel: string;
+            subtitle: string;
+            bitrate: number;
+            mode: "direct" | "remux" | "transcode";
+            player: string;
+            device: string;
+            network: "LAN" | "WAN";
+            ip: string;
+            state: "buffering" | "paused" | "playing";
+            positionMs: number;
+            bufferedMs?: number | null | undefined;
+            durationMs: number | null;
+            startedAt: number;
+        }[];
+    }>;
+    /** An empty `message` falls back to the client's localized default. */
+    terminateSession: (id: PlaybackSessionId, message?: string) => Promise<void>;
+    /** `range` defaults to the live rolling window; anything else is read from
+     * the samples the server has persisted. */
+    metrics: (range?: MetricRange) => Promise<{
+        cpuKroma: number;
+        cpuSystem: number;
+        cpuMedia: number;
+        mediaProcs: number;
+        cores: number;
+        ramKromaBytes: number;
+        ramUsedBytes: number;
+        ramTotalBytes: number;
+        bwLocalMbps: number;
+        bwRemoteMbps: number;
+        uptimeSecs: number;
+        sampleIntervalMs: number;
+        series: {
+            cpuKroma: number[];
+            cpuSystem: number[];
+            cpuMedia: number[];
+            ramKroma: number[];
+            ramSystem: number[];
+            bwLocal: number[];
+            bwRemote: number[];
+        };
+        range: "12h" | "1y" | "24h" | "30d" | "7d" | "90d" | "all" | "live";
+        startedAt: number;
+        stepSecs: number;
+        means?: {
+            cpuKroma: number;
+            cpuSystem: number;
+            cpuMedia: number;
+            ramKroma: number;
+            ramSystem: number;
+            bwLocal: number;
+            bwRemote: number;
+        } | null | undefined;
+        complete: boolean;
+    }>;
+    /** Every remux running now, the silicon they run on, and whether each is
+     * keeping ahead of the player. */
+    transcodes: () => Promise<{
+        hardware: {
+            accel: string;
+            reason: string;
+            accelerated: boolean;
+        };
+        sessions: {
+            id: string;
+            itemId: string & z.$brand<"ItemId">;
+            audioTrack: number;
+            video: string;
+            audio: string;
+            transcodesVideo: boolean;
+            transcodesAudio: boolean;
+            accel: string;
+            effort: string;
+            onTheCpu: boolean;
+            pid?: number | null | undefined;
+            sourceWidth?: number | null | undefined;
+            sourceHeight?: number | null | undefined;
+            targetWidth?: number | null | undefined;
+            targetHeight?: number | null | undefined;
+            anchorSecs: number;
+            startedAt: number;
+            speed: number;
+            fps: number;
+            frames: number;
+            dropped: number;
+            outTimeMs: number;
+            segments: number;
+            bytes: number;
+            running: boolean;
+            title?: string | null | undefined;
+            showTitle?: string | null | undefined;
+            season?: number | null | undefined;
+            episode?: number | null | undefined;
+            cpu?: number | null | undefined;
+        }[];
+        encoding: number;
+        cacheBytes: number;
+    }>;
+    storage: () => Promise<{
+        totalBytes: number;
+        usedBytes: number;
+        availableBytes: number;
+        volumes: {
+            totalBytes: number;
+            usedBytes: number;
+            availableBytes: number;
+            name: string;
+            mount: string;
+            fs: string;
+        }[];
+        mediaBytes: number;
+        cache: {
+            dir: string;
+            bytes: number;
+            limit: string;
+            transcodeBytes: number;
+            transcodeLimit: string;
+            imagesBytes: number;
+            imagesCount: number;
+            enrichedItems: number;
+            enrichedShows: number;
+            embeddings: number;
+        };
+    }>;
+    /** Wipes the transcode + image caches; requires `settings.manage`. */
+    clearCache: () => Promise<{
+        freedBytes: number;
+    }>;
+    /** Drops every resolved TMDB metadata so the next enrichment re-fetches from
+     * scratch; requires `settings.manage`. */
+    resetMetadata: () => Promise<{
+        items: number;
+        shows: number;
+    }>;
+    /** Requires `users.manage`. */
+    users: () => Promise<{
+        users: {
+            id: string & z.$brand<"UserId">;
+            email: string;
+            username: string;
+            avatarUrl?: string | null | undefined;
+            createdAt: string;
+            hasPin: boolean;
+            permissions: ("library.manage" | "playback" | "reports.manage" | "requests.auto" | "requests.create" | "requests.manage" | "settings.manage" | "users.manage")[];
+            role: string;
+            lastSeen?: string | null | undefined;
+            online: boolean;
+            emailVerified: boolean;
+            resetRequested: boolean;
+        }[];
+        libraryCount: number;
+    }>;
+    updateUser: (id: UserId, patch: AdminUserPatch) => Promise<void>;
+    deleteUser: (id: UserId) => Promise<void>;
+    /** Mint a credential reset (requires `users.manage`). The returned `code` is
+     * the one-time code the owner reads to the user; it is never stored in clear. */
+    resetUser: (id: UserId) => Promise<{
+        token: string;
+        code: string;
+        url: string | null;
+        expiresAt: number;
+        delivered: "manual" | "smtp";
+    }>;
+    /** Clear a user's profile PIN (requires `users.manage`). Remembered devices
+     * re-lock and ask for the account credential on the next switch-in. */
+    clearUserPin: (id: UserId) => Promise<void>;
+    /** Mint an email-verification link for the account's current address and try
+     * to deliver it (requires `users.manage`). No code: reaching the mailbox is
+     * itself the proof. */
+    sendEmailVerification: (id: UserId) => Promise<{
+        token: string;
+        url: string | null;
+        expiresAt: number;
+        delivered: "manual" | "smtp";
+    }>;
+    settings: (view: string) => Promise<{
+        view: string;
+        groups: {
+            title: string;
+            desc?: string | null | undefined;
+            rows: {
+                key: string;
+                label: string;
+                desc?: string | null | undefined;
+                kind: string;
+                options: string[];
+                value: unknown;
+                applied: boolean;
+                configured?: boolean | null | undefined;
+            }[];
+        }[];
+    }>;
+    /** Resolves with the keys actually written. */
+    updateSettings: (patch: Record<string, unknown>) => Promise<{
+        updated: string[];
+    }>;
+    /** Sends a short probe to the caller's own address with the saved SMTP
+     * settings; resolves with the address it went to. */
+    testSmtp: () => Promise<{
+        sentTo: string;
+    }>;
+    overview: () => Promise<{
+        users: number;
+        online: number;
+        invites: number;
+        items: number;
+        shows: number;
+        libraries: number;
+    }>;
+    topUsers: (days?: number) => Promise<{
+        users: {
+            username: string;
+            userId?: (string & z.$brand<"UserId">) | null | undefined;
+            avatarUrl?: string | null | undefined;
+            plays: number;
+            watchedMs: number;
+            filmsMs: number;
+            tvMs: number;
+            byKind?: Record<"movie" | "tv", number> | null | undefined;
+        }[];
+    }>;
+    /** The titles played most over a window, one column per kind of media. */
+    mostWatched: (opts?: {
+        days?: number;
+        user?: UserId;
+    }) => Promise<{
+        columns: {
+            kind: "movie" | "tv";
+            entries: {
+                itemId: string & z.$brand<"ItemId">;
+                title: string;
+                kind: "movie" | "tv";
+                year?: number | null | undefined;
+                posterUrl?: string | null | undefined;
+                plays: number;
+                viewers: number;
+            }[];
+        }[];
+    }>;
+    /** Time watched per bucket over a window, stacked by kind. `kind` and `user`
+     * narrow it the way the dashboard panel's two other filters do; a bare number
+     * is the window in days. */
+    history: (opts?: number | HistoryWindow) => Promise<{
+        buckets: {
+            label: string;
+            filmsMs: number;
+            tvMs: number;
+        }[];
+        totalFilmsMs: number;
+        totalTvMs: number;
+        totals?: Record<"movie" | "tv", number> | null | undefined;
+        bucketDays: number;
+    }>;
+    /** The watch log, newest first: who watched what, when, and on which device.
+     * `sort` is a column name plus `:asc` or `:desc`. */
+    plays: (opts?: {
+        days?: number;
+        user?: UserId;
+        library?: string;
+        /** An item or show id, for one title's own history. */
+        item?: string;
+        sort?: string;
+        limit?: number;
+        offset?: number;
+    }) => Promise<{
+        plays: {
+            id: string;
+            userId?: (string & z.$brand<"UserId">) | null | undefined;
+            username: string;
+            itemId?: (string & z.$brand<"ItemId">) | null | undefined;
+            showId?: (string & z.$brand<"ShowId">) | null | undefined;
+            inCatalog: boolean;
+            kind: string;
+            title: string;
+            showTitle?: string | null | undefined;
+            season?: number | null | undefined;
+            episode?: number | null | undefined;
+            device?: string | null | undefined;
+            player?: string | null | undefined;
+            mode?: "direct" | "remux" | "transcode" | null | undefined;
+            network?: "LAN" | "WAN" | null | undefined;
+            videoLabel?: string | null | undefined;
+            audioLabel?: string | null | undefined;
+            library?: (string & z.$brand<"LibraryId">) | null | undefined;
+            startedAt: number;
+            endedAt: number;
+            watchedMs: number;
+        }[];
+        total: number;
+    }>;
+    /** Newest last. `level` is a minimum severity, `source` is `core` or a
+     * module id, `q` is a case-insensitive substring. */
+    logs: (opts?: {
+        level?: string;
+        source?: string;
+        q?: string;
+        limit?: number;
+    }) => Promise<{
+        entries: {
+            seq: number;
+            ts: number;
+            level: string;
+            target: string;
+            source: string;
+            message: string;
+        }[];
+        sources: string[];
+    }>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        admin: ReturnType<typeof adminApi>;
+    }
+}
+export {};

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

@@ -0,0 +1,7 @@
+export type { BackupImportOptions, BackupImportResult } from './backup';
+export * from './client';
+export * from './logs';
+export * from './metrics';
+export * from './settings';
+export * from './stats';
+export * from './users';

package/types/client/src/api/admin/logs.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+/** One line of the server's in-memory log ring (`GET /api/admin/logs`). */
+export declare const LogEntry: z.ZodObject<{
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    level: z.ZodString;
+    target: z.ZodString;
+    source: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type LogEntry = z.infer<typeof LogEntry>;
+/** `GET /api/admin/logs` recent lines (newest last) + the sources present. */
+export declare const LogsView: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodNumber;
+        level: z.ZodString;
+        target: z.ZodString;
+        source: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    sources: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LogsView = z.infer<typeof LogsView>;