@kromatv/sdk 0.1.40-canary.0

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

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+export declare const NotificationCategory: z.ZodEnum<{
+    downloads: "downloads";
+    media: "media";
+    reports: "reports";
+    requests: "requests";
+    system: "system";
+}>;
+export type NotificationCategory = z.infer<typeof NotificationCategory>;
+/** The events the server names today. It owns this vocabulary and grows it, so
+ * the wire field is an open string: a client built before an addition must still
+ * render the row. */
+export declare const KnownNotificationEvent: z.ZodEnum<{
+    custom: "custom";
+    "download.failed": "download.failed";
+    "download.imported": "download.imported";
+    "media.added": "media.added";
+    "media.episode": "media.episode";
+    "report.dismissed": "report.dismissed";
+    "report.resolved": "report.resolved";
+    "report.submitted": "report.submitted";
+    "request.approved": "request.approved";
+    "request.available": "request.available";
+    "request.denied": "request.denied";
+    "request.submitted": "request.submitted";
+    "system.disk.low": "system.disk.low";
+    "system.job.failed": "system.job.failed";
+    "system.test": "system.test";
+}>;
+export type KnownNotificationEvent = z.infer<typeof KnownNotificationEvent>;
+export declare const KNOWN_NOTIFICATION_EVENTS: ("custom" | "download.failed" | "download.imported" | "media.added" | "media.episode" | "report.dismissed" | "report.resolved" | "report.submitted" | "request.approved" | "request.available" | "request.denied" | "request.submitted" | "system.disk.low" | "system.job.failed" | "system.test")[];
+/** A known event, or any string a newer server sends. */
+export type NotificationEvent = KnownNotificationEvent | (string & {});
+/** `link` navigates to an in-app route; `api` calls the server from the row. */
+export declare const ActionKind: z.ZodEnum<{
+    api: "api";
+    link: "link";
+}>;
+export type ActionKind = z.infer<typeof ActionKind>;
+export declare const ActionStyle: z.ZodEnum<{
+    danger: "danger";
+    default: "default";
+    primary: "primary";
+}>;
+export type ActionStyle = z.infer<typeof ActionStyle>;
+export declare const NotificationAction: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        api: "api";
+        link: "link";
+    }>;
+    href: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    style: z.ZodDefault<z.ZodEnum<{
+        danger: "danger";
+        default: "default";
+        primary: "primary";
+    }>>;
+}, z.core.$strip>;
+export type NotificationAction = z.infer<typeof NotificationAction>;
+export declare const Notification: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "NotificationId", "out">;
+    category: z.ZodEnum<{
+        downloads: "downloads";
+        media: "media";
+        reports: "reports";
+        requests: "requests";
+        system: "system";
+    }>;
+    event: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodString;
+    link: z.ZodOptional<z.ZodString>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+    actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            api: "api";
+            link: "link";
+        }>;
+        href: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        style: z.ZodDefault<z.ZodEnum<{
+            danger: "danger";
+            default: "default";
+            primary: "primary";
+        }>>;
+    }, z.core.$strip>>>;
+    read: z.ZodBoolean;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+export type Notification = z.infer<typeof Notification>;
+/** `GET /api/notifications`. */
+export declare const NotificationsView: z.ZodObject<{
+    notifications: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "NotificationId", "out">;
+        category: z.ZodEnum<{
+            downloads: "downloads";
+            media: "media";
+            reports: "reports";
+            requests: "requests";
+            system: "system";
+        }>;
+        event: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodString;
+        link: z.ZodOptional<z.ZodString>;
+        imageUrl: z.ZodOptional<z.ZodString>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                api: "api";
+                link: "link";
+            }>;
+            href: z.ZodString;
+            method: z.ZodOptional<z.ZodString>;
+            style: z.ZodDefault<z.ZodEnum<{
+                danger: "danger";
+                default: "default";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>>;
+        read: z.ZodBoolean;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    unread: z.ZodNumber;
+}, z.core.$strip>;
+export type NotificationsView = z.infer<typeof NotificationsView>;
+export declare const CategoryPref: z.ZodObject<{
+    category: z.ZodEnum<{
+        downloads: "downloads";
+        media: "media";
+        reports: "reports";
+        requests: "requests";
+        system: "system";
+    }>;
+    inApp: z.ZodBoolean;
+    push: z.ZodBoolean;
+}, z.core.$strip>;
+export type CategoryPref = z.infer<typeof CategoryPref>;
+/** `GET`/`PUT /api/notifications/prefs`. */
+export declare const NotificationPrefs: z.ZodObject<{
+    categories: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            downloads: "downloads";
+            media: "media";
+            reports: "reports";
+            requests: "requests";
+            system: "system";
+        }>;
+        inApp: z.ZodBoolean;
+        push: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NotificationPrefs = z.infer<typeof NotificationPrefs>;
+/**
+ * How a push subscription reaches its device. `webpush` signs with the server's
+ * own VAPID key; `relay` carries a push.kroma.tv grant instead of a device token,
+ * because Apple and Google only accept credentials issued to the app's publisher;
+ * `apns` / `fcm` carry a raw device token and need those publisher credentials.
+ */
+export declare const PushTransport: z.ZodEnum<{
+    apns: "apns";
+    fcm: "fcm";
+    relay: "relay";
+    webpush: "webpush";
+}>;
+export type PushTransport = z.infer<typeof PushTransport>;
+/** `POST /api/push/subscribe`. Web Push sends `endpoint` plus both keys; the
+ * native transports send the device token (or relay grant) as `endpoint` and
+ * omit the keys. */
+export declare const SubscribeBody: z.ZodObject<{
+    transport: z.ZodEnum<{
+        apns: "apns";
+        fcm: "fcm";
+        relay: "relay";
+        webpush: "webpush";
+    }>;
+    endpoint: z.ZodString;
+    p256dh: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodString>;
+    device: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SubscribeBody = z.infer<typeof SubscribeBody>;
+/** Who the console is addressing when it sends a notification by hand. */
+export declare const NotificationTarget: z.ZodEnum<{
+    admins: "admins";
+    everyone: "everyone";
+    me: "me";
+}>;
+export type NotificationTarget = z.infer<typeof NotificationTarget>;
+/** `POST /api/admin/notifications` body: either a core `event` to sample or
+ * hand-written text; a `title` wins. */
+export declare const SendNotificationBody: z.ZodObject<{
+    category: z.ZodExactOptional<z.ZodEnum<{
+        downloads: "downloads";
+        media: "media";
+        reports: "reports";
+        requests: "requests";
+        system: "system";
+    }>>;
+    title: z.ZodExactOptional<z.ZodString>;
+    body: z.ZodExactOptional<z.ZodString>;
+    link: z.ZodExactOptional<z.ZodOptional<z.ZodString>>;
+    imageUrl: z.ZodExactOptional<z.ZodOptional<z.ZodString>>;
+    event: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodEnum<{
+        admins: "admins";
+        everyone: "everyone";
+        me: "me";
+    }>>;
+}, z.core.$strip>;
+export type SendNotificationBody = z.infer<typeof SendNotificationBody>;
+/** One image previously uploaded for a notification. `uploadedAt` is epoch
+ * milliseconds of the stored file's mtime. */
+export declare const NotificationImage: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    uploadedAt: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type NotificationImage = z.infer<typeof NotificationImage>;
+/** `GET /api/admin/notifications/images` newest first, capped server-side. */
+export declare const NotificationImages: z.ZodObject<{
+    images: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        uploadedAt: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NotificationImages = z.infer<typeof NotificationImages>;

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

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import type { SubjectId } from '../media';
+import { type SubjectKind } from './schemas';
+/** The processing pipeline: stage control, failed-task retries and the
+ * per-element view the admin drills into. */
+export default function pipelineApi(ctx: RequestContext): {
+    overview: () => Promise<{
+        stages: {
+            stage: string;
+            key: string;
+            subjectKind: string;
+            pending: number;
+            running: number;
+            done: number;
+            failed: number;
+            blocked: number;
+        }[];
+        paused: boolean;
+    }>;
+    /** Newest first. */
+    failed: (stage: string) => Promise<{
+        tasks: {
+            stage: string;
+            subjectKind: string;
+            subjectId: string;
+            title: string;
+            status: string;
+            attempts: number;
+            error: string | null;
+            finishedAt: number | null;
+        }[];
+    }>;
+    run: (stage: string) => Promise<{
+        runId: string & z.$brand<"JobRunId">;
+    }>;
+    cancel: (stage: string) => Promise<{
+        cancelled: boolean;
+    }>;
+    /** Holds or releases every stage at once. */
+    pause: (paused: boolean) => Promise<{
+        paused: boolean;
+    }>;
+    /** Resets a stage's failed tasks to pending. */
+    retry: (stage: string) => Promise<{
+        requeued: number;
+    }>;
+    /** Puts every non-running task of a stage back to pending. */
+    reprocess: (stage: string) => Promise<{
+        requeued: number;
+    }>;
+    retryTask: (stage: string, subjectId: SubjectId) => Promise<{
+        requeued: number;
+    }>;
+    /** Filtered, paginated elements with per-treatment status + full counts. */
+    elements: (params?: {
+        status?: string;
+        kind?: string;
+        q?: string;
+        page?: number;
+        limit?: number;
+    }) => Promise<{
+        total: number;
+        page: number;
+        pages: number;
+        counts: {
+            total: number;
+            ok: number;
+            pending: number;
+            running: number;
+            failed: number;
+            film: number;
+            series: number;
+            episode: number;
+        };
+        elements: {
+            id: string;
+            kind: string;
+            title: string;
+            poster: string | null;
+            year: number | null;
+            genre: string | null;
+            durationMs: number | null;
+            seasonCount: number | null;
+            treatments: {
+                key: string;
+                status: string;
+                error?: string | null | undefined;
+            }[];
+            overall: string;
+            epStats?: {
+                episodes: number;
+                probed: number;
+                storyboarded: number;
+                seasons: number;
+                markerSeasons: number;
+            } | null | undefined;
+        }[];
+    }>;
+    retryElement: (kind: SubjectKind, id: SubjectId, stage: string) => Promise<void>;
+    item: (id: SubjectId) => Promise<{
+        treatments: {
+            key: string;
+            status: string;
+            error?: string | null | undefined;
+        }[];
+    }>;
+    /** Aggregated across the series' episodes. */
+    show: (id: SubjectId) => Promise<{
+        treatments: {
+            key: string;
+            status: string;
+            error?: string | null | undefined;
+        }[];
+    }>;
+    /** Clears the element's artifacts, requeues its tasks and kicks every stage. */
+    reprocessSubject: (kind: SubjectKind, id: SubjectId) => Promise<{
+        subjects: number;
+        stages: string[];
+    }>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        pipeline: ReturnType<typeof pipelineApi>;
+    }
+}

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

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

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

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+/** One treatment applied to a catalog element, and whether it has been done. */
+export declare const Treatment: z.ZodObject<{
+    key: z.ZodString;
+    status: z.ZodString;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type Treatment = z.infer<typeof Treatment>;
+/** Which half of the catalog a pipeline action is aimed at. */
+export declare const SubjectKind: z.ZodEnum<{
+    item: "item";
+    show: "show";
+}>;
+export type SubjectKind = z.infer<typeof SubjectKind>;
+/** Health counters for one pipeline stage, aggregated from the ledger. */
+export declare const StageStat: z.ZodObject<{
+    stage: z.ZodString;
+    key: z.ZodString;
+    subjectKind: z.ZodString;
+    pending: z.ZodNumber;
+    running: z.ZodNumber;
+    done: z.ZodNumber;
+    failed: z.ZodNumber;
+    blocked: z.ZodNumber;
+}, z.core.$strip>;
+export type StageStat = z.infer<typeof StageStat>;
+/** Status tally over ALL elements (unfiltered), for the filter chips + header. */
+export declare const ElementCounts: z.ZodObject<{
+    total: z.ZodNumber;
+    ok: z.ZodNumber;
+    pending: z.ZodNumber;
+    running: z.ZodNumber;
+    failed: z.ZodNumber;
+    film: z.ZodNumber;
+    series: z.ZodNumber;
+    episode: z.ZodNumber;
+}, z.core.$strip>;
+export type ElementCounts = z.infer<typeof ElementCounts>;
+/** Every treatment that applies to an element + whether it has been done. */
+export declare const ElementProcessing: z.ZodObject<{
+    treatments: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        status: z.ZodString;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ElementProcessing = z.infer<typeof ElementProcessing>;
+/** One catalog element (film / series / episode) with per-treatment status. */
+export declare const ElementRow: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    title: z.ZodString;
+    poster: z.ZodNullable<z.ZodString>;
+    year: z.ZodNullable<z.ZodNumber>;
+    genre: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    seasonCount: z.ZodNullable<z.ZodNumber>;
+    treatments: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        status: z.ZodString;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    overall: z.ZodString;
+    epStats: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        episodes: z.ZodNumber;
+        probed: z.ZodNumber;
+        storyboarded: z.ZodNumber;
+        seasons: z.ZodNumber;
+        markerSeasons: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ElementRow = z.infer<typeof ElementRow>;
+/** `GET /api/admin/pipeline/elements`: a filtered, paginated page of the catalog. */
+export declare const PipelineElements: z.ZodObject<{
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pages: z.ZodNumber;
+    counts: z.ZodObject<{
+        total: z.ZodNumber;
+        ok: z.ZodNumber;
+        pending: z.ZodNumber;
+        running: z.ZodNumber;
+        failed: z.ZodNumber;
+        film: z.ZodNumber;
+        series: z.ZodNumber;
+        episode: z.ZodNumber;
+    }, z.core.$strip>;
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        title: z.ZodString;
+        poster: z.ZodNullable<z.ZodString>;
+        year: z.ZodNullable<z.ZodNumber>;
+        genre: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        seasonCount: z.ZodNullable<z.ZodNumber>;
+        treatments: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            status: z.ZodString;
+            error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        overall: z.ZodString;
+        epStats: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            episodes: z.ZodNumber;
+            probed: z.ZodNumber;
+            storyboarded: z.ZodNumber;
+            seasons: z.ZodNumber;
+            markerSeasons: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PipelineElements = z.infer<typeof PipelineElements>;
+/** One failed (or otherwise notable) ledger row, for the stage drill-down. */
+export declare const PipelineTaskView: z.ZodObject<{
+    stage: z.ZodString;
+    subjectKind: z.ZodString;
+    subjectId: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    attempts: z.ZodNumber;
+    error: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type PipelineTaskView = z.infer<typeof PipelineTaskView>;
+/** `GET /api/admin/pipeline`: every stage's health, in DAG order. */
+export declare const PipelineView: z.ZodObject<{
+    stages: z.ZodArray<z.ZodObject<{
+        stage: z.ZodString;
+        key: z.ZodString;
+        subjectKind: z.ZodString;
+        pending: z.ZodNumber;
+        running: z.ZodNumber;
+        done: z.ZodNumber;
+        failed: z.ZodNumber;
+        blocked: z.ZodNumber;
+    }, z.core.$strip>>;
+    paused: z.ZodBoolean;
+}, z.core.$strip>;
+export type PipelineView = z.infer<typeof PipelineView>;