@kromatv/sdk 0.1.39-canary.3579809

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

@@ -0,0 +1,336 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import { type GrabBody, type SearchScope } from './acquisition';
+import type { RequestId } from './ids';
+import { type CreateRequestBody, type RequestCoverage } from './schemas';
+/** Media requests: submit (an Overseerr-style ask for a title), track your own,
+ * and moderate the queue with `requests.manage`. */
+export default function requestsApi(ctx: RequestContext): {
+    /** Own requests, or everyone's for a `requests.manage` holder. `mine: true`
+     * forces own-only (the user-facing "Mes demandes" page). */
+    list: (opts?: {
+        mine?: boolean;
+    }) => Promise<{
+        requests: {
+            seasons: number[] | null;
+            episodes: {
+                season: number;
+                episode: number;
+            }[] | null;
+            id: string & z.$brand<"RequestId">;
+            kind: "movie" | "show";
+            tmdbId: number;
+            title: string;
+            year: number | null;
+            posterUrl: string | null;
+            status: "approved" | "available" | "denied" | "downloading" | "failed" | "importing" | "partially_available" | "pending" | "searching";
+            requestedBy: (string & z.$brand<"UserId">) | null;
+            requestedByName: string | null;
+            reviewedBy: (string & z.$brand<"UserId">) | null;
+            note: string | null;
+            createdAt: number;
+            updatedAt: number;
+            progress: number | null;
+            airStatus: string | null;
+            nextAirDate: string | null;
+        }[];
+        counts: {
+            total: number;
+            pending: number;
+            active: number;
+            available: number;
+            denied: number;
+            failed: number;
+        };
+    }>;
+    /** The "coming soon" calendar: upcoming, not-yet-available releases, oldest
+     * date first. `mine: true` forces own-only. */
+    calendar: (opts?: {
+        mine?: boolean;
+    }) => Promise<{
+        requestId: (string & z.$brand<"RequestId">) | null;
+        tmdbId: number;
+        kind: "movie" | "show";
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        season: number | null;
+        episode: number | null;
+        episodeTitle: string | null;
+        airDate: string | null;
+        status: string;
+    }[]>;
+    /** The "missing / wanted" list: aired or released items still not on disk,
+     * the inverse of the calendar. `mine: true` forces own-only. */
+    missing: (opts?: {
+        mine?: boolean;
+    }) => Promise<{
+        requestId: (string & z.$brand<"RequestId">) | null;
+        tmdbId: number;
+        kind: "movie" | "show";
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        season: number | null;
+        episode: number | null;
+        episodeTitle: string | null;
+        airDate: string | null;
+        status: string;
+    }[]>;
+    /** Kick the acquisition search pass now (requests.manage), auto-grabbing the
+     * best release for every aired-but-open item. */
+    searchAllMissing: () => Promise<{
+        runId: string & z.$brand<"JobRunId">;
+    }>;
+    /** Search this one request and grab the best accepted release
+     * (requests.manage). Slow: a live indexer sweep. */
+    autoSearch: (id: RequestId) => Promise<{
+        grabbed: boolean;
+        title?: string | undefined;
+    }>;
+    /** Submit a request. A second ask for the same title merges into the open
+     * one (a show ask can widen its season subset). */
+    create: (body: CreateRequestBody) => Promise<{
+        seasons: number[] | null;
+        episodes: {
+            season: number;
+            episode: number;
+        }[] | null;
+        id: string & z.$brand<"RequestId">;
+        kind: "movie" | "show";
+        tmdbId: number;
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        status: "approved" | "available" | "denied" | "downloading" | "failed" | "importing" | "partially_available" | "pending" | "searching";
+        requestedBy: (string & z.$brand<"UserId">) | null;
+        requestedByName: string | null;
+        reviewedBy: (string & z.$brand<"UserId">) | null;
+        note: string | null;
+        createdAt: number;
+        updatedAt: number;
+        progress: number | null;
+        airStatus: string | null;
+        nextAirDate: string | null;
+    }>;
+    /** Withdraw an own pending request, or (as a manager) delete any request. */
+    delete: (id: RequestId) => Promise<void>;
+    /** Approve (requests.manage): materializes the wanted list, kicks the search. */
+    approve: (id: RequestId) => Promise<{
+        seasons: number[] | null;
+        episodes: {
+            season: number;
+            episode: number;
+        }[] | null;
+        id: string & z.$brand<"RequestId">;
+        kind: "movie" | "show";
+        tmdbId: number;
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        status: "approved" | "available" | "denied" | "downloading" | "failed" | "importing" | "partially_available" | "pending" | "searching";
+        requestedBy: (string & z.$brand<"UserId">) | null;
+        requestedByName: string | null;
+        reviewedBy: (string & z.$brand<"UserId">) | null;
+        note: string | null;
+        createdAt: number;
+        updatedAt: number;
+        progress: number | null;
+        airStatus: string | null;
+        nextAirDate: string | null;
+    }>;
+    /** Deny (requests.manage), with an optional reason shown to the requester. */
+    deny: (id: RequestId, note?: string) => Promise<{
+        seasons: number[] | null;
+        episodes: {
+            season: number;
+            episode: number;
+        }[] | null;
+        id: string & z.$brand<"RequestId">;
+        kind: "movie" | "show";
+        tmdbId: number;
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        status: "approved" | "available" | "denied" | "downloading" | "failed" | "importing" | "partially_available" | "pending" | "searching";
+        requestedBy: (string & z.$brand<"UserId">) | null;
+        requestedByName: string | null;
+        reviewedBy: (string & z.$brand<"UserId">) | null;
+        note: string | null;
+        createdAt: number;
+        updatedAt: number;
+        progress: number | null;
+        airStatus: string | null;
+        nextAirDate: string | null;
+    }>;
+    /** A request's wanted ledger (requests.manage): every season/episode it
+     * covers with its state, which is what a search can be aimed at. */
+    wanted: (id: RequestId) => Promise<{
+        id: string & z.$brand<"WantedId">;
+        season: number | null;
+        episode: number | null;
+        airDate: string | null;
+        status: string;
+    }[]>;
+    /** Set exactly what a show request covers (requests.manage): the whole show
+     * (both null), some seasons, some episodes, or a mix. The wanted ledger is
+     * reconciled to match, episodes that stay in scope keeping their state, so
+     * this is also how the automatic search pass is told what to hunt for. */
+    setCoverage: (id: RequestId, body: RequestCoverage) => Promise<{
+        seasons: number[] | null;
+        episodes: {
+            season: number;
+            episode: number;
+        }[] | null;
+        id: string & z.$brand<"RequestId">;
+        kind: "movie" | "show";
+        tmdbId: number;
+        title: string;
+        year: number | null;
+        posterUrl: string | null;
+        status: "approved" | "available" | "denied" | "downloading" | "failed" | "importing" | "partially_available" | "pending" | "searching";
+        requestedBy: (string & z.$brand<"UserId">) | null;
+        requestedByName: string | null;
+        reviewedBy: (string & z.$brand<"UserId">) | null;
+        note: string | null;
+        createdAt: number;
+        updatedAt: number;
+        progress: number | null;
+        airStatus: string | null;
+        nextAirDate: string | null;
+    }>;
+    /** The requested title as TMDB describes it (requests.manage): every season,
+     * with how much of it the request covers and how much the library holds.
+     * Wider than `wanted`, which only knows the request's own rows; this is what
+     * says which episodes are MISSING. */
+    ledger: (id: RequestId) => Promise<{
+        kind: "movie" | "show";
+        tmdbId: number;
+        title: string;
+        year: number | null;
+        today: string;
+        coverage: {
+            seasons: number[] | null;
+            episodes: {
+                season: number;
+                episode: number;
+            }[] | null;
+        };
+        posterUrl: string | null;
+        backdropUrl: string | null;
+        overview: string | null;
+        seasons: {
+            season: number;
+            name: string | null;
+            airDate: string | null;
+            episodeCount: number;
+            requested: number;
+            onDisk: number;
+            posterUrl?: string | null | undefined;
+        }[];
+        localId: string | null;
+        onDisk: boolean;
+        airDate: string | null;
+    }>;
+    /** One season's episodes from TMDB (requests.manage), flagged against the
+     * ledger and the library. Fetched a season at a time: a twenty-season show
+     * is one TMDB call per season the admin actually opens. */
+    seasonLedger: (id: RequestId, season: number) => Promise<{
+        season: number;
+        episodes: {
+            season: number;
+            episode: number;
+            name: string | null;
+            overview: string | null;
+            airDate: string | null;
+            stillUrl: string | null;
+            rating: number | null;
+            onDisk: boolean;
+            wantedId: (string & z.$brand<"WantedId">) | null;
+            wantedStatus: string | null;
+            heldByRequest: boolean;
+            itemId: (string & z.$brand<"ItemId">) | null;
+            video: {
+                codec: string;
+                width: number | null;
+                height: number | null;
+                hdr: boolean;
+                bitDepth: number | null;
+                hdrFormat?: "dolbyVision" | "hdr10" | "hdr10Plus" | "hlg" | null | undefined;
+                dolbyVisionProfile?: number | null | undefined;
+                color?: {
+                    primaries?: string | null | undefined;
+                    transfer?: string | null | undefined;
+                    matrix?: string | null | undefined;
+                } | null | undefined;
+            } | null;
+            durationMs: number | null;
+        }[];
+    }>;
+    /** Interactive search (requests.manage): a live sweep of every enabled
+     * indexer for this request, narrowed to `scope` (the whole request by
+     * default), returning scored releases and rejects with reasons. Slow. */
+    searchReleases: (id: RequestId, scope?: SearchScope) => Promise<{
+        releases: {
+            title: string;
+            guid: string;
+            indexerId: string & z.$brand<"IndexerId">;
+            indexerName: string;
+            sizeBytes: number | null;
+            seeders: number | null;
+            leechers: number | null;
+            publishedAt: string | null;
+            target: string;
+            season: number | null;
+            episodes: number[] | null;
+            score: number | null;
+            breakdown: {
+                rule: string;
+                delta: number;
+                note: string;
+                code: string;
+                params: Record<string, unknown>;
+            }[];
+            rejected: string | null;
+            refusal?: {
+                rule: string;
+                params: Record<string, unknown>;
+            } | null | undefined;
+            flags: ("doubleUpload" | "freeleech" | "halfleech")[];
+            grabbable: boolean;
+            upgrade: boolean;
+            detailsUrl: string | null;
+            quality?: string | null | undefined;
+            formats: {
+                name: string;
+                score: number;
+            }[];
+            verdict?: {
+                kind: "fill";
+            } | {
+                kind: "upgrade";
+                reason: "cutoffReached" | "formats" | "lowerQuality" | "noBetterFormats" | "notAllowed" | "quality" | "revision" | "upgradesOff";
+            } | {
+                kind: "beside";
+                reason: "cutoffReached" | "formats" | "lowerQuality" | "noBetterFormats" | "notAllowed" | "quality" | "revision" | "upgradesOff";
+            } | {
+                kind: "notBetter";
+                reason: "cutoffReached" | "formats" | "lowerQuality" | "noBetterFormats" | "notAllowed" | "quality" | "revision" | "upgradesOff";
+            } | null | undefined;
+        }[];
+        indexers: {
+            id: string & z.$brand<"IndexerId">;
+            name: string;
+            found: number;
+            error: string | null;
+            elapsedMs: number;
+        }[];
+    }>;
+    /** Manually grab one release from the last interactive search. */
+    grab: (id: RequestId, body: GrabBody) => Promise<void>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        requests: ReturnType<typeof requestsApi>;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+export declare const RequestKind: z.ZodEnum<{
+    movie: "movie";
+    show: "show";
+}>;
+export type RequestKind = z.infer<typeof RequestKind>;
+export declare const RequestStatus: z.ZodEnum<{
+    approved: "approved";
+    available: "available";
+    denied: "denied";
+    downloading: "downloading";
+    failed: "failed";
+    importing: "importing";
+    partially_available: "partially_available";
+    pending: "pending";
+    searching: "searching";
+}>;
+export type RequestStatus = z.infer<typeof RequestStatus>;
+export declare const RequestCounts: z.ZodObject<{
+    total: z.ZodNumber;
+    pending: z.ZodNumber;
+    active: z.ZodNumber;
+    available: z.ZodNumber;
+    denied: z.ZodNumber;
+    failed: z.ZodNumber;
+}, z.core.$strip>;
+export type RequestCounts = z.infer<typeof RequestCounts>;
+export declare const EpisodeRef: z.ZodObject<{
+    season: z.ZodNumber;
+    episode: z.ZodNumber;
+}, z.core.$strip>;
+export type EpisodeRef = z.infer<typeof EpisodeRef>;
+/** What a show request covers: the union of whole `seasons` and individual
+ * `episodes`; both null means the whole show. Also the `PUT
+ * /api/requests/:id/coverage` body, which is the same shape said forwards:
+ * unlike a second ask, it can narrow as well as widen. */
+export declare const RequestCoverage: z.ZodObject<{
+    seasons: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    episodes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        season: z.ZodNumber;
+        episode: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RequestCoverage = z.infer<typeof RequestCoverage>;
+export declare const MediaRequest: z.ZodObject<{
+    seasons: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    episodes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        season: z.ZodNumber;
+        episode: z.ZodNumber;
+    }, z.core.$strip>>>;
+    id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+    kind: z.ZodEnum<{
+        movie: "movie";
+        show: "show";
+    }>;
+    tmdbId: z.ZodNumber;
+    title: z.ZodString;
+    year: z.ZodNullable<z.ZodNumber>;
+    posterUrl: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        approved: "approved";
+        available: "available";
+        denied: "denied";
+        downloading: "downloading";
+        failed: "failed";
+        importing: "importing";
+        partially_available: "partially_available";
+        pending: "pending";
+        searching: "searching";
+    }>;
+    requestedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "UserId", "out">>;
+    requestedByName: z.ZodNullable<z.ZodString>;
+    reviewedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "UserId", "out">>;
+    note: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    progress: z.ZodNullable<z.ZodNumber>;
+    airStatus: z.ZodNullable<z.ZodString>;
+    nextAirDate: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type MediaRequest = z.infer<typeof MediaRequest>;
+/** `GET /api/requests`. */
+export declare const RequestsView: z.ZodObject<{
+    requests: z.ZodArray<z.ZodObject<{
+        seasons: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        episodes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            season: z.ZodNumber;
+            episode: z.ZodNumber;
+        }, z.core.$strip>>>;
+        id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+        kind: z.ZodEnum<{
+            movie: "movie";
+            show: "show";
+        }>;
+        tmdbId: z.ZodNumber;
+        title: z.ZodString;
+        year: z.ZodNullable<z.ZodNumber>;
+        posterUrl: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            approved: "approved";
+            available: "available";
+            denied: "denied";
+            downloading: "downloading";
+            failed: "failed";
+            importing: "importing";
+            partially_available: "partially_available";
+            pending: "pending";
+            searching: "searching";
+        }>;
+        requestedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "UserId", "out">>;
+        requestedByName: z.ZodNullable<z.ZodString>;
+        reviewedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "UserId", "out">>;
+        note: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        progress: z.ZodNullable<z.ZodNumber>;
+        airStatus: z.ZodNullable<z.ZodString>;
+        nextAirDate: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    counts: z.ZodObject<{
+        total: z.ZodNumber;
+        pending: z.ZodNumber;
+        active: z.ZodNumber;
+        available: z.ZodNumber;
+        denied: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RequestsView = z.infer<typeof RequestsView>;
+/** Shared by `GET /api/requests/calendar` (future-dated, `airDate` always set)
+ * and `GET /api/requests/missing` (aired but not on disk, `airDate` may be
+ * null). `requestId` is null for a library-scan row nobody requested;
+ * `episodeTitle` is set only where the library holds the show's season guide. */
+export declare const CalendarEntry: z.ZodObject<{
+    requestId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
+    tmdbId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        movie: "movie";
+        show: "show";
+    }>;
+    title: z.ZodString;
+    year: z.ZodNullable<z.ZodNumber>;
+    posterUrl: z.ZodNullable<z.ZodString>;
+    season: z.ZodNullable<z.ZodNumber>;
+    episode: z.ZodNullable<z.ZodNumber>;
+    episodeTitle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    airDate: z.ZodNullable<z.ZodString>;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type CalendarEntry = z.infer<typeof CalendarEntry>;
+/** `POST /api/requests` body. */
+export declare const CreateRequestBody: z.ZodObject<{
+    kind: z.ZodEnum<{
+        movie: "movie";
+        show: "show";
+    }>;
+    tmdbId: z.ZodNumber;
+    seasons: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    episodes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        season: z.ZodNumber;
+        episode: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type CreateRequestBody = z.infer<typeof CreateRequestBody>;

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { RequestContext } from '../../core/client';
+import type { ItemId } from '../media';
+import { GenerationId, type SubtitleId } from './ids';
+import { type GenerateReq } from './schemas';
+/** On-device subtitle generation: transcribe the audio (Whisper) or translate an
+ * existing track (LLM), poll live progress, cancel, and delete generated tracks. */
+export default function subtitlesApi(ctx: RequestContext): {
+    /** Which generation actions this server build enables. */
+    capabilities: (id: ItemId) => Promise<{
+        transcribe: boolean;
+        translate: boolean;
+    }>;
+    /** This item's already-generated subtitles. */
+    downloaded: (id: ItemId) => Promise<{
+        id: string & z.$brand<"SubtitleId">;
+        language: string | null;
+        label: string;
+        provider: string;
+        url: string;
+    }[]>;
+    /** Delete a generated subtitle track (its row and its cached file). */
+    delete: (id: ItemId, subId: SubtitleId) => Promise<void>;
+    /** Start a generation. Returns at once with a `genId`; poll
+     * {@link subtitlesApi.generations} for progress, then refresh the list. */
+    generate: (id: ItemId, req: GenerateReq) => Promise<{
+        genId: string & z.$brand<"GenerationId">;
+    }>;
+    /** Live + recently-finished generations for this item. */
+    generations: (id: ItemId) => Promise<{
+        id: string & z.$brand<"GenerationId">;
+        mode: "transcribe" | "translate";
+        lang: string | null;
+        stage: string;
+        status: "done" | "error" | "running";
+        progress: number;
+        etaSec: number | null;
+        error: string | null;
+        subId: (string & z.$brand<"SubtitleId">) | null;
+    }[]>;
+    /** Request cancellation of a running generation. */
+    cancel: (id: ItemId, genId: GenerationId) => Promise<void>;
+};
+declare module '../../core/client' {
+    interface Domains {
+        subtitles: ReturnType<typeof subtitlesApi>;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+/** Generation mode: speech-to-text, or translate an existing track. */
+export declare const GenMode: z.ZodEnum<{
+    transcribe: "transcribe";
+    translate: "translate";
+}>;
+export type GenMode = z.infer<typeof GenMode>;
+/** Whisper model tier (Rapide / Équilibré / Précis). */
+export declare const GenQuality: z.ZodEnum<{
+    accurate: "accurate";
+    balanced: "balanced";
+    fast: "fast";
+}>;
+export type GenQuality = z.infer<typeof GenQuality>;
+/** Whisper model tiers offered by the generate sheet, in order. */
+export declare const GEN_QUALITIES: ("accurate" | "balanced" | "fast")[];
+/** Target / spoken languages offered by the generate sheet. `code` is the
+ * Whisper hint; `label` is the track name, chosen so the server resolves it back
+ * to a language code. One source of truth for every client's generate UI. */
+export declare const GEN_LANGS: ReadonlyArray<{
+    code: string;
+    label: string;
+}>;
+/** A generated + cached subtitle, with its WebVTT URL (relative to the server). */
+export declare const DownloadedSub: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "SubtitleId", "out">;
+    language: z.ZodNullable<z.ZodString>;
+    label: z.ZodString;
+    provider: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type DownloadedSub = z.infer<typeof DownloadedSub>;
+/** Which generation actions the server build + config enable, so a client can
+ * hide UI that would do nothing. */
+export declare const SubCapabilities: z.ZodObject<{
+    transcribe: z.ZodBoolean;
+    translate: z.ZodBoolean;
+}, z.core.$strip>;
+export type SubCapabilities = z.infer<typeof SubCapabilities>;
+/** A generation request. For `translate`, give `sourceTrack` (an embedded index)
+ * or `sourceSubId` (a generated track); the server resolves the source text. */
+export declare const GenerateReq: z.ZodObject<{
+    mode: z.ZodEnum<{
+        transcribe: "transcribe";
+        translate: "translate";
+    }>;
+    lang: z.ZodString;
+    spokenLang: z.ZodOptional<z.ZodString>;
+    quality: z.ZodOptional<z.ZodEnum<{
+        accurate: "accurate";
+        balanced: "balanced";
+        fast: "fast";
+    }>>;
+    audioTrack: z.ZodOptional<z.ZodNumber>;
+    sourceTrack: z.ZodOptional<z.ZodNumber>;
+    sourceSubId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SubtitleId", "out">>;
+}, z.core.$strip>;
+export type GenerateReq = z.infer<typeof GenerateReq>;
+/** A live (or recently finished) generation, as polled. `progress` is 0..1. */
+export declare const SubtitleGeneration: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "GenerationId", "out">;
+    mode: z.ZodEnum<{
+        transcribe: "transcribe";
+        translate: "translate";
+    }>;
+    lang: z.ZodNullable<z.ZodString>;
+    stage: z.ZodString;
+    status: z.ZodEnum<{
+        done: "done";
+        error: "error";
+        running: "running";
+    }>;
+    progress: z.ZodNumber;
+    etaSec: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+    subId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "SubtitleId", "out">>;
+}, z.core.$strip>;
+export type SubtitleGeneration = z.infer<typeof SubtitleGeneration>;

package/types/client/src/core/client.d.ts

@@ -0,0 +1,17 @@
+import type { RequestContext } from './http';
+export type { Query, RequestContext } from './http';
+/**
+ * Every namespace `KromaClient` carries.
+ *
+ * Nothing enumerates them. A domain declares itself into this interface from
+ * its own `src/api/<name>/client.ts`, and the runtime finds the same folder by
+ * globbing, so adding a domain is adding a folder.
+ */
+export interface Domains {
+}
+/** A domain's endpoints over the shared transport. Each `client.ts` default-exports one. */
+export type DomainFactory = (ctx: RequestContext) => object;
+/** The folder name out of a globbed path: `./media/client.ts` is `media`. */
+export declare function domainKey(path: string): string;
+/** Hand one context to every discovered domain. */
+export declare function bindDomains(ctx: RequestContext, factories: Readonly<Record<string, DomainFactory>>): Domains;

package/types/client/src/core/http/adopt-media-ticket.d.ts

@@ -0,0 +1,6 @@
+import type { RequestContext } from './request-context';
+/** Hand the transport the media ticket a sign-in answered with, so the URLs a
+ * player fetches for itself carry it, and pass the answer through untouched. An
+ * answer with no ticket in it leaves the held one alone: a poll that is still
+ * pending and a server too old to mint one are both silence, not a revocation. */
+export declare function adoptMediaTicket<T>(ctx: RequestContext, signIn: Promise<T>): Promise<T>;