@kromatv/sdk 0.1.39-canary.3579809

package/types/module-sdk/src/admin/action-control.d.ts

@@ -0,0 +1,3 @@
+export declare function ActionControl({ actionKey }: Readonly<{
+    actionKey: string;
+}>): import("react").JSX.Element | null;

package/types/module-sdk/src/admin/apply-setting.d.ts

@@ -0,0 +1,2 @@
+import type { SettingGroup } from '@kromatv/client/admin';
+export declare function applySetting(groups: SettingGroup[], key: string, value: unknown): SettingGroup[];

package/types/module-sdk/src/admin/context.d.ts

@@ -0,0 +1,20 @@
+import type { KromaClient } from '@kromatv/client';
+import type { User } from '@kromatv/client/accounts';
+import { type ReactNode } from 'react';
+export interface AdminHostValue {
+    client: KromaClient;
+    user: User | null;
+    apiBase: string;
+    /** Open the host's "media details" dialog for a catalog item. A service the
+     *  shell owns and a module borrows: the dialog reads the core catalog, which
+     *  is not a module's to know, but a module page listing files has every
+     *  reason to offer it. Absent on a shell that has no such dialog. */
+    openMediaInfo?: (itemId: string, title: string) => void;
+}
+export declare function AdminHostProvider({ value, children, }: Readonly<{
+    value: AdminHostValue;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** The host-provided client / user / apiBase. Throws if used outside the
+ *  provider (which the admin shell always mounts). */
+export declare function useAdminHost(): AdminHostValue;

package/types/module-sdk/src/admin/control.d.ts

@@ -0,0 +1,5 @@
+import type { SettingRow } from '@kromatv/client/admin';
+export declare function Control({ row, onChange, }: Readonly<{
+    row: SettingRow;
+    onChange: (v: unknown) => void;
+}>): import("react").JSX.Element;

package/types/module-sdk/src/admin/denied.d.ts

@@ -0,0 +1 @@
+export declare function Denied(): import("react").JSX.Element;

package/types/module-sdk/src/admin/editable-text.d.ts

@@ -0,0 +1,5 @@
+export declare function EditableText({ label, value, onCommit, }: Readonly<{
+    label: string;
+    value: string;
+    onCommit: (v: string) => void;
+}>): import("react").JSX.Element;

package/types/module-sdk/src/admin/engines.d.ts

@@ -0,0 +1,38 @@
+import type { EngineContribution, EngineField } from '@kromatv/client/modules';
+import { type ReactNode } from 'react';
+/** A contribution the add-picker can offer: it names the instance an added row
+ * stores, and it has either a field form or a custom flow. */
+export type EngineChoice = EngineContribution & {
+    id: string;
+};
+/** The enabled contributors to `point` that expose an add-flow. A disabled
+ * module contributes nothing, so its add-flow disappears from the page. */
+export declare function useEnabledEngines(point: string): EngineChoice[];
+/** Whether each module is enabled, as a predicate. For a caller checking a
+ * VARIABLE number of modules, where one `useModuleEnabled` per id would be a
+ * hook in a loop. Unknown ids answer true, matching {@link useModuleEnabled}. */
+export declare function useModuleEnabledCheck(): (id: string) => boolean;
+/** Whether module `id` is enabled. Defaults to true while loading / when unknown,
+ * so nothing flickers off before the module list resolves. */
+export declare function useModuleEnabled(id: string): boolean;
+/** A controlled form over an engine's declared fields. Every label resolves
+ * through `t()`, so a field key like `field.url` localizes while a proper-noun
+ * engine label (`Transmission`) passes through unchanged. */
+export declare function FieldForm({ fields, values, onChange, }: Readonly<{
+    fields: EngineField[];
+    values: Record<string, string>;
+    onChange: (key: string, value: string) => void;
+}>): import("react").JSX.Element;
+export interface AddEngineOptions {
+    engines: EngineChoice[];
+    title: string;
+    onSubmit: (engineId: string, values: Record<string, string>) => Promise<void>;
+}
+type AddEngine = (options: Readonly<AddEngineOptions>) => Promise<boolean>;
+/** Request a form from this admin root; fail closed without a host. */
+export declare function useAddEngine(): AddEngine;
+/** Wrap the admin root whose engine-add requests this host draws. */
+export declare function AddEngineHost({ children }: Readonly<{
+    children?: ReactNode;
+}>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/admin/hooks.d.ts

@@ -0,0 +1,39 @@
+import { type Permission, type User } from '@kromatv/client/accounts';
+import { type QueryKey } from '@tanstack/react-query';
+/** Polls `fn` every `intervalMs` through TanStack Query. Prefix `key` with `'admin'`
+ * so `invalidateQueries(['admin'])` refreshes it, and put varying inputs in `key`.
+ *
+ * `loading` is true only until the FIRST answer; a later poll that fails leaves
+ * the last good `data` in place and raises `failed`. `error` is that failure's
+ * cause, for a page that says WHY rather than only that it failed. */
+export declare function usePoll<T>(key: QueryKey, fn: () => Promise<T>, intervalMs: number): {
+    data: T | null;
+    loading: boolean;
+    failed: boolean;
+    error: unknown;
+    reload: () => Promise<void>;
+};
+/** Fetches `fn` once through TanStack Query and keeps the answer, for data that
+ * does not move: a torrent's file list, a season's episode names. Same shape as
+ * {@link usePoll}, so the two are interchangeable at a call site.
+ *
+ * A `null` key holds the request back until the inputs it needs exist, and
+ * reports `loading: false` while it waits, because nothing is in flight. */
+export declare function useFetch<T>(key: QueryKey | null, fn: () => Promise<T>): {
+    data: T | null;
+    loading: boolean;
+    failed: boolean;
+    error: unknown;
+    reload: () => Promise<void>;
+};
+/** `run(fn, onError?)` flips `busy` while `fn` runs and, on failure, sets `error` to `onError(e)`. */
+export declare function useAsyncAction(): {
+    busy: boolean;
+    error: string | null;
+    run: (fn: () => Promise<void>, onError?: (e: unknown) => string) => Promise<void>;
+};
+/** True if the user holds any management capability, which unlocks the console.
+ * `requests.manage` counts: a moderator needs the shell for the requests queue. */
+export declare function isAnyAdmin(user: Pick<User, 'permissions'> | null | undefined): boolean;
+/** Whether the current user satisfies `cap` (or is any admin when `cap` is null). */
+export declare function useCap(cap?: Permission | null): boolean;

package/types/module-sdk/src/admin/page-states.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The shape of a console page, pulsing: a title, a subtitle, and the panels
+ * under them. Deliberately the page's OWN silhouette rather than a spinner -
+ * it says what is coming and holds the layout, so nothing jumps when the real
+ * page lands.
+ */
+export declare function ModuleLoading({ panels }: Readonly<{
+    panels?: number;
+}>): import("react").JSX.Element;
+/** A module that is not installed, or has been turned off: its pages vanish
+ *  with its nav, and this says so rather than 404-ing. */
+export declare function ModuleUnavailable(): import("react").JSX.Element;
+interface ModuleFailedProps {
+    /** Offered as a Retry button; a page that cannot ask again omits it. */
+    retry?: () => void;
+    /** The thrown cause, which chooses the explanation: a request that never
+     *  reached a server reads as the server being down, an HTTP answer as the
+     *  module's. Without one the state falls back to the generic wording. */
+    error?: unknown;
+    /** The raw text under that explanation. Defaults to what `error` carries. */
+    detail?: string;
+}
+/** A module page whose own data could not be fetched. Distinct from
+ *  {@link ModuleUnavailable}: the module IS there, the request failed. Pass
+ *  `retry` where the page can ask again, and the state offers the button. */
+export declare function ModuleFailed({ retry, error, detail }: Readonly<ModuleFailedProps>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/admin/row.d.ts

@@ -0,0 +1,5 @@
+import type { SettingRow } from '@kromatv/client/admin';
+export declare const Row: import("react").MemoExoticComponent<({ row, onChange, }: Readonly<{
+    row: SettingRow;
+    onChange: (key: string, v: unknown) => void;
+}>) => import("react").JSX.Element>;

package/types/module-sdk/src/admin/secret-input.d.ts

@@ -0,0 +1,5 @@
+export declare function SecretInput({ configured, masked, onCommit, }: Readonly<{
+    configured: boolean;
+    masked: boolean;
+    onCommit: (v: string) => void;
+}>): import("react").JSX.Element;

package/types/module-sdk/src/admin/setting-actions.d.ts

@@ -0,0 +1,19 @@
+import type { KromaClient } from '@kromatv/client';
+import type { MessageKey } from '@kromatv/i18n';
+import type { useT } from '@kromatv/ui';
+type T = ReturnType<typeof useT>;
+export interface ActionSpec {
+    label: MessageKey;
+    running: MessageKey;
+    failed: MessageKey;
+    run: (client: KromaClient) => Promise<{
+        sentTo: string;
+        asked?: boolean;
+    }>;
+    ok: (t: T, r: {
+        sentTo: string;
+        asked?: boolean;
+    }) => string;
+}
+export declare const ACTIONS: Record<string, ActionSpec>;
+export {};

package/types/module-sdk/src/admin/setting-select.d.ts

@@ -0,0 +1,8 @@
+/** Keeps the current value selectable even if it isn't in the list, so a
+ * stored setting the schema no longer names still shows. */
+export declare function SettingSelect({ label, value, options, onChange, }: Readonly<{
+    label: string;
+    value: string;
+    options: string[];
+    onChange: (v: string) => void;
+}>): import("react").JSX.Element;

package/types/module-sdk/src/admin/settings.d.ts

@@ -0,0 +1,9 @@
+import type { MessageKey } from '@kromatv/i18n';
+interface SettingsViewProps {
+    view: string;
+    titleKey: MessageKey;
+    subtitleKey: MessageKey;
+    embedded?: boolean;
+}
+export declare function SettingsView(props: Readonly<SettingsViewProps>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/bus.d.ts

@@ -0,0 +1,8 @@
+import type { KromaEvents } from './contracts';
+export type EventKey = Extract<keyof KromaEvents, string>;
+export interface EventBus {
+    emit<K extends EventKey>(key: K, payload: KromaEvents[K]): void;
+    on<K extends EventKey>(key: K, handler: (payload: KromaEvents[K]) => void): () => void;
+}
+/** Dispatch is synchronous: `emit` returns once every handler has run. */
+export declare function createEventBus(): EventBus;

package/types/module-sdk/src/contracts.d.ts

@@ -0,0 +1,6 @@
+/** Maps a module id to the API it exports for other modules to consume. */
+export interface ModuleApiRegistry {
+}
+/** Maps an event name to its payload type. */
+export interface KromaEvents {
+}

package/types/module-sdk/src/define.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentType } from 'react';
+import type { KromaHost } from './host';
+import type { AnySlotContribution, KromaModule, ModuleComponentProps, NavItem, SettingsPanel } from './module';
+import type { Dependencies } from './types';
+/** The absolute URL a module page lives at: admin sections under `/admin/<path>`,
+ *  everything else under `/<path>`. The single source of truth, so the route and
+ *  the nav link cannot drift. */
+export declare function pageHref(section: string, path: string): string;
+/** One page a module contributes: a route, plus nav metadata when it should show
+ *  in a sidebar. Omit `nav` for deep links and detail pages. */
+export interface ModulePage {
+    path: string;
+    component: ComponentType<ModuleComponentProps>;
+    nav?: Omit<NavItem, 'to'> & {
+        section: string;
+    };
+}
+export interface ModuleManifestInput {
+    id: string;
+    version: string;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+}
+export interface DefineModuleOptions<Exports = unknown> {
+    manifest?: ModuleManifestInput;
+    locales?: Record<string, Record<string, string>>;
+    pages?: ModulePage[];
+    settingsPanels?: SettingsPanel[];
+    slots?: AnySlotContribution[];
+    exports?: (host: KromaHost) => Exports;
+    setup?: (host: KromaHost) => void | Promise<void>;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+}
+/** Build a `KromaModule` from its manifest + pages. `defineModule({ pages })` has
+ *  the manifest and locales injected by the `@kromatv/module-sdk/vite` plugin;
+ *  `defineModule(manifest, { pages })` is the explicit form for when it is off. */
+export declare function defineModule<Exports = unknown>(manifestOrOptions: ModuleManifestInput | DefineModuleOptions<Exports>, maybeOptions?: DefineModuleOptions<Exports>): KromaModule<Exports>;

package/types/module-sdk/src/events.d.ts

@@ -0,0 +1,11 @@
+import { type ServerEvent } from '@kromatv/client/events';
+/** Subscribe to the server's event socket. A module widens the frame union
+ *  with its own event types, declared in its package, not in core:
+ *
+ *  ```ts
+ *  useServerEvents<DownloadProgressEvent | VpnStatusEvent>((e) => { ... });
+ *  ```
+ */
+export declare function useServerEvents<M extends {
+    type: string;
+} = never>(onEvent: (e: ServerEvent | M) => void): void;

package/types/module-sdk/src/host.d.ts

@@ -0,0 +1,32 @@
+import type { EventBus } from './bus';
+import type { ModuleApiRegistry } from './contracts';
+import type { ModuleManifest } from './types';
+/** The slice of the server API the host grants modules. The web host adapts its
+ *  concrete `KromaClient` to this; a module never depends on the client package. */
+export interface HostApi {
+    get<T>(path: string): Promise<T>;
+    listModules(): Promise<ModuleManifest[]>;
+}
+export interface HostAuth {
+    readonly userId: string | null;
+    can(capability: string): boolean;
+}
+export interface HostI18n {
+    t(key: string, vars?: Record<string, unknown>): string;
+    readonly locale: string;
+}
+export interface HostNav {
+    navigate(to: string): void;
+}
+/** Everything a module receives at setup. */
+export interface KromaHost {
+    api: HostApi;
+    auth: HostAuth;
+    i18n: HostI18n;
+    nav: HostNav;
+    bus: EventBus;
+    getModuleApi<K extends keyof ModuleApiRegistry>(id: K): ModuleApiRegistry[K] | undefined;
+}
+/** What the host provides to the registry; `getModuleApi` is wired by the
+ *  registry itself, so the caller supplies everything except that. */
+export type HostBase = Omit<KromaHost, 'getModuleApi'>;

package/types/module-sdk/src/icon.d.ts

@@ -0,0 +1 @@
+export declare function moduleIconUrl(id: string, baseUrl?: string): string;

package/types/module-sdk/src/index.d.ts

@@ -0,0 +1,35 @@
+export { apiErrorText, brandedId, type KromaClient } from '@kromatv/client';
+export { KromaEvents as KromaEventStream, type ServerEvent } from '@kromatv/client/events';
+export { ItemId } from '@kromatv/client/media';
+export { type EngineContribution, type ModuleApi, ModuleId } from '@kromatv/client/modules';
+export { IndexerId, RequestId } from '@kromatv/client/requests';
+export type { MessageKey } from '@kromatv/i18n';
+export { useFormat, useLocale } from '@kromatv/ui';
+export type { AdminHostValue } from './admin/context';
+export { AdminHostProvider, useAdminHost } from './admin/context';
+export { Denied } from './admin/denied';
+export type { AddEngineOptions, EngineChoice } from './admin/engines';
+export { AddEngineHost, FieldForm, useAddEngine, useEnabledEngines, useModuleEnabled, useModuleEnabledCheck, } from './admin/engines';
+export { isAnyAdmin, useAsyncAction, useCap, useFetch, usePoll } from './admin/hooks';
+export { ModuleFailed, ModuleLoading, ModuleUnavailable } from './admin/page-states';
+export { SettingsView } from './admin/settings';
+export type { EventBus, EventKey } from './bus';
+export { createEventBus } from './bus';
+export type { KromaEvents, ModuleApiRegistry } from './contracts';
+export type { DefineModuleOptions, ModuleManifestInput, ModulePage } from './define';
+export { defineModule, pageHref } from './define';
+export { useServerEvents } from './events';
+export type { HostApi, HostAuth, HostBase, HostI18n, HostNav, KromaHost } from './host';
+export { moduleIconUrl } from './icon';
+export type { KromaModule, ModuleComponentProps, NavItem, RouteDef, SettingsPanel, SlotContribution, SlotName, SlotProps, } from './module';
+export type { ModuleNav, ModulePanel, ModuleRoute, ModuleSlotEntry, ModuleStatus, } from './registry';
+export { depEntries, ModuleRegistry } from './registry';
+export { ModuleScope, moduleApiHook, useModuleApi, useT } from './scope';
+export type { SharedModule } from './shared';
+export { PUBLIC_NAME, REMOTE_ENTRY, REMOTE_STYLES, remoteEntryUrl, SHARED_GLOBAL, SHARED_MODULES, sharedKey, } from './shared';
+export { ModuleSlot, ModuleSlotProvider, useSlotEntries } from './slot';
+export type { ConfigField, Contribution, Dependencies, FeRemote, ModuleManifest, PointReq, } from './types';
+export type { SortColumn, TableActionProps, TableCellProps, TableColumn, TableColumnProps, TableRootProps, TableRowProps, } from './ui/table';
+export { TABULAR, Table } from './ui/table';
+export type { PlainColumn, SortableColumn, SortDirection, SortedColumn, SortedTable, SortedTableOptions, TableHeading, TableOrder, TablePage, TableQuery, } from './use-sorted-table';
+export { useSortedTable } from './use-sorted-table';

package/types/module-sdk/src/module.d.ts

@@ -0,0 +1,108 @@
+import type { RequestId } from '@kromatv/client/requests';
+import type { ComponentType } from 'react';
+import type { KromaHost } from './host';
+import type { Dependencies } from './types';
+export interface NavItem {
+    to: string;
+    label: string;
+    icon?: string;
+    section?: string;
+    requires?: string;
+}
+export interface ModuleComponentProps {
+    host: KromaHost;
+}
+/** A route registered under the host's module mount point. */
+export interface RouteDef {
+    path: string;
+    component: ComponentType<ModuleComponentProps>;
+}
+export interface SettingsPanel {
+    id: string;
+    label: string;
+    component: ComponentType<ModuleComponentProps>;
+}
+/**
+ * A place a CORE page opens for modules to fill.
+ *
+ * The core cannot import a module -- it does not know which are installed, and
+ * a page that named one would break the moment it was disabled. So the page
+ * renders a named slot and passes it props; a module answers the name. The name
+ * is the contract between them, and its props are declared in {@link SlotProps}.
+ */
+export interface SlotContribution<Name extends SlotName = SlotName> {
+    slot: Name;
+    component: ComponentType<SlotProps[Name]>;
+    /** Lower renders first when several modules fill one slot. Defaults to 0. */
+    order?: number;
+}
+/**
+ * Every slot a core page opens, and what it hands whoever fills it.
+ *
+ * Declared here so both sides typecheck against one definition: a core page
+ * cannot pass props no module expects, and a module cannot claim a slot that
+ * does not exist. Adding a slot is a change to this map first.
+ */
+export interface SlotProps {
+    /** The acquisition half of the admin request page: search for releases of
+     *  this request and grab one. Everything about indexers, releases and
+     *  downloads lives behind it. */
+    'requests.detail': {
+        requestId: RequestId;
+        kind: 'movie' | 'show';
+        title: string;
+        canGrab: boolean;
+    };
+    /** Beside one episode row of the request page's catalogue: how far along the
+     *  download of that episode is, if anything is downloading it. */
+    'requests.episode.progress': {
+        requestId: RequestId;
+        season: number;
+        episode: number;
+    };
+    /** The acquisition half of the admin page of one title: which quality profile
+     *  judges it, how its files measure up, and a search for a better copy.
+     *  `monitored` is false for a library title nobody monitors yet. */
+    'monitoring.detail': {
+        kind: 'movie' | 'show';
+        tmdbId: number;
+        title: string;
+        monitored: boolean;
+    };
+    /** The search actions for one title, one season or one episode, wherever a
+     *  core page lists them: an automatic search and a hand-picked one. `season`
+     *  and `episode` narrow the search; both null searches the whole title.
+     *  `compact` asks for icon buttons that fit a table row. */
+    /** The library page's « À améliorer » tab: titles that hold a copy the
+     *  server would still replace. The tab shows only when a module registers
+     *  for it. */
+    'library.upgrades': Record<never, never>;
+    'monitoring.search': {
+        kind: 'movie' | 'show';
+        tmdbId: number;
+        title: string;
+        season: number | null;
+        episode: number | null;
+        compact: boolean;
+    };
+}
+export type SlotName = keyof SlotProps;
+/** A contribution to SOME slot, each element matched to its own slot's props.
+ *  `SlotContribution` alone would default to the union of every slot's props and
+ *  demand a component that accepts all of them at once. */
+export type AnySlotContribution = {
+    [Name in SlotName]: SlotContribution<Name>;
+}[SlotName];
+export interface KromaModule<Exports = unknown> {
+    id: string;
+    version: string;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+    routes?: RouteDef[];
+    navItems?: NavItem[];
+    settingsPanels?: SettingsPanel[];
+    slots?: AnySlotContribution[];
+    locales?: Record<string, Record<string, string>>;
+    exports?: (host: KromaHost) => Exports;
+    setup?: (host: KromaHost) => void | Promise<void>;
+}

package/types/module-sdk/src/registry.d.ts

@@ -0,0 +1,69 @@
+import type { HostBase, KromaHost } from './host';
+import type { AnySlotContribution, KromaModule, NavItem, RouteDef, SettingsPanel, SlotName } from './module';
+import type { Dependencies, ModuleManifest } from './types';
+/** A `{ id: range }` dependency map as a flat list; `"*"` means no constraint. */
+export declare function depEntries(deps?: Dependencies | null): {
+    id: string;
+    version?: string;
+}[];
+export type ModuleRoute = RouteDef & {
+    moduleId: string;
+};
+export type ModuleNav = NavItem & {
+    moduleId: string;
+};
+export type ModulePanel = SettingsPanel & {
+    moduleId: string;
+};
+export type ModuleSlotEntry = AnySlotContribution & {
+    moduleId: string;
+};
+export interface ModuleStatus {
+    id: string;
+    frontend: true;
+    backend: boolean;
+    manifest?: ModuleManifest;
+}
+/** Where a module's own message catalogs go when it registers. The host passes
+ *  its i18n instance's `addCatalogs`; a registry built without one, as a test
+ *  or a story does, simply keeps the messages to itself. */
+export type CatalogSink = (scope: string, catalogs: Record<string, Record<string, string>>) => () => void;
+export declare class ModuleRegistry {
+    private readonly catalogs;
+    private readonly modules;
+    private readonly setupDone;
+    private readonly disposers;
+    private readonly listeners;
+    private readonly slotCache;
+    /** The catalog sink is where a registering module's messages are published. The
+     *  default drops them, so a registry is inert until a host wires one in and
+     *  two registries in one process cannot tread on each other. */
+    constructor(catalogs?: CatalogSink);
+    register(module: KromaModule): this;
+    /** Remove a module, e.g. to roll back a runtime remote whose deps don't
+     *  resolve before it breaks `order()` for everyone else. */
+    unregister(id: string): void;
+    /** Calls `listener` after every register and unregister; returns the
+     *  unsubscribe. A bound property, so `useSyncExternalStore` sees one function. */
+    readonly subscribe: (listener: () => void) => (() => void);
+    private changed;
+    has(id: string): boolean;
+    ids(): string[];
+    /** Modules in initialization order (dependencies first). Throws on a missing
+     *  hard dependency or a cycle; version ranges are the backend's business. */
+    order(): KromaModule[];
+    /** Resolve the graph, compute each module's exports and run its setup in
+     *  dependency order, then return the wired host. Ids in `skipSetup` are not
+     *  set up, and a module's setup runs at most once across calls. */
+    start(base: HostBase, skipSetup?: ReadonlySet<string>): Promise<KromaHost>;
+    navItems(): ModuleNav[];
+    routes(): ModuleRoute[];
+    /** Everything registered for one slot, in `order` then dependency order. The
+     *  caller decides whether a module is ENABLED: this registry only knows what
+     *  was registered. */
+    slotsFor(slot: SlotName): ModuleSlotEntry[];
+    settingsPanels(): ModulePanel[];
+    /** Cross-check registered frontend modules against the backend manifest: an
+     *  id absent from `/api/modules` comes back `backend: false`. */
+    reconcile(manifest: ModuleManifest[]): ModuleStatus[];
+}

package/types/module-sdk/src/scope.d.ts

@@ -0,0 +1,23 @@
+import { type ModuleApi } from '@kromatv/client/modules';
+import { useScopedT } from '@kromatv/ui';
+import { type ReactNode } from 'react';
+/** Mounted by the host around a module's page, carrying that module's id. */
+export declare function ModuleScope({ id, children }: Readonly<{
+    id: string;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** Translate against THIS module's catalog first, then the app's. Outside a
+ *  module page it is the app's translator unchanged. */
+export declare function useT(): ReturnType<ReturnType<typeof useScopedT>>;
+/** This module's own admin API, bound to `/api/admin/m/<its id>`. Paths are
+ *  relative to that mount, so `get('/vpn')` reads the module's own `/vpn`. */
+export declare function useModuleApi(): ModuleApi;
+/** Build a module's typed API hook from a factory over its `ModuleApi`.
+ *
+ *  `moduleApiHook(factory)` binds to whichever module the host is rendering
+ *  (via `ModuleScope`), so the module never names itself. The `(id, factory)`
+ *  form binds an explicit id instead: that is the shape for an API other
+ *  packages call: the id others reach the module at, published once, next to
+ *  the methods it addresses. */
+export declare function moduleApiHook<T>(factory: (api: ModuleApi) => T): () => T;
+export declare function moduleApiHook<T>(id: string, factory: (api: ModuleApi) => T): () => T;

package/types/module-sdk/src/shared.d.ts

@@ -0,0 +1,21 @@
+/** Every import specifier a module bundle takes from the host, by exact name. */
+export declare const SHARED_MODULES: readonly ['react', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'react-dom', 'react-native', '@kromatv/module-sdk', '@kromatv/ui', '@kromatv/ui/kit', '@kromatv/ui/tokens', '@kromatv/core', '@kromatv/core/react', '@kromatv/client', '@kromatv/client/query', '@kromatv/i18n', '@kromatv/i18n/react', '@tanstack/react-query', '@tanstack/react-router', 'react-call'];
+export type SharedModule = (typeof SHARED_MODULES)[number];
+/**
+ * What the host provides for an import specifier: the specifier itself when it
+ * is shared, `@kromatv/ui/kit` for a deep kit import (the barrel exports every
+ * component, and the host holds one copy of it), and `null` for a package the
+ * bundle carries itself.
+ */
+export declare function sharedKey(specifier: string): string | null;
+/** The published package's name, and the specifier a module written against it
+ *  imports the SDK by. The host provides it as `@kromatv/module-sdk`. */
+export declare const PUBLIC_NAME = "@kromatv/sdk";
+/** The global the host fills with `{ [specifier]: module namespace }` before it
+ *  imports a module's remote entry. */
+export declare const SHARED_GLOBAL = "__KROMA_SHARED__";
+/** The bundle's entry file under `fe/`, and the stylesheet beside it. */
+export declare const REMOTE_ENTRY = "remoteEntry.js";
+export declare const REMOTE_STYLES = "style.css";
+/** Where the server serves a module's `fe/` from. */
+export declare function remoteEntryUrl(baseUrl: string, id: string): string;

package/types/module-sdk/src/slot.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from 'react';
+import type { SlotName, SlotProps } from './module';
+import type { ModuleRegistry, ModuleSlotEntry } from './registry';
+/** Hands the shell's registry to every `<ModuleSlot>` below it. Mounted once,
+ *  beside `<AdminHostProvider>`. Without it a slot renders its fallback, which
+ *  is what a shell that contributes no modules should show anyway. */
+export declare function ModuleSlotProvider({ registry, children, }: Readonly<{
+    registry: ModuleRegistry | null;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** What is registered for `slot`, before the enabled check. Follows the registry,
+ *  so a module that registers after the slot first rendered still fills it. */
+export declare function useSlotEntries(slot: SlotName): ModuleSlotEntry[];
+type ModuleSlotProps<Name extends SlotName> = {
+    name: Name;
+    /** Shown when no enabled module fills the slot: the module is absent, or off.
+     *  Absent fallback renders nothing, for a slot that is a decoration. */
+    fallback?: ReactNode;
+} & SlotProps[Name];
+/**
+ * Render whatever enabled modules contribute to `name`, in their declared order.
+ *
+ * ```tsx
+ * <ModuleSlot
+ *   name="requests.detail"
+ *   requestId={req.id}
+ *   kind={req.kind}
+ *   title={req.title}
+ *   canGrab={canModerate}
+ *   fallback={<NoAcquisitionModule />}
+ * />
+ * ```
+ */
+export declare function ModuleSlot<Name extends SlotName>({ name, fallback, ...props }: Readonly<ModuleSlotProps<Name>>): import("react").JSX.Element;
+export {};