@camstack/types 1.1.32 → 1.1.34

package/dist/capabilities/streaming-engine.cap.d.ts

@@ -1,61 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-declare const StreamFormatSchema: z.ZodEnum<{
-    rtsp: "rtsp";
-    webrtc: "webrtc";
-    hls: "hls";
-    mjpeg: "mjpeg";
-}>;
-declare const StreamInfoSchema: z.ZodObject<{
-    streamId: z.ZodString;
-    format: z.ZodEnum<{
-        rtsp: "rtsp";
-        webrtc: "webrtc";
-        hls: "hls";
-        mjpeg: "mjpeg";
-    }>;
-    url: z.ZodNullable<z.ZodString>;
-    active: z.ZodBoolean;
-}, z.core.$strip>;
-export declare const streamingEngineCapability: {
-    readonly name: "streaming-engine";
-    readonly scope: "system";
-    readonly mode: "singleton";
-    readonly internal: true;
-    readonly methods: {
-        readonly registerStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-            sourceUrl: z.ZodString;
-            codec: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly unregisterStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly getStreamUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-            format: z.ZodEnum<{
-                rtsp: "rtsp";
-                webrtc: "webrtc";
-                hls: "hls";
-                mjpeg: "mjpeg";
-            }>;
-        }, z.core.$strip>, z.ZodNullable<z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly listStreams: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
-            streamId: z.ZodString;
-            format: z.ZodEnum<{
-                rtsp: "rtsp";
-                webrtc: "webrtc";
-                hls: "hls";
-                mjpeg: "mjpeg";
-            }>;
-            url: z.ZodNullable<z.ZodString>;
-            active: z.ZodBoolean;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-    };
-    /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-    readonly mount: {
-        readonly kind: "skip";
-    };
-};
-export type IStreamingEngineProvider = InferProvider<typeof streamingEngineCapability>;
-export { StreamFormatSchema, StreamInfoSchema };

package/dist/capabilities/webrtc.cap.d.ts

@@ -1,75 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-/**
- * Optional client-side hints sent at session creation to help the
- * provider pick the best native source. All fields are optional —
- * a viewer that knows nothing still gets a sane default.
- */
-export declare const webrtcClientHintsSchema: z.ZodObject<{
-    viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-    viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-    devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-    downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-    prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-export type WebrtcClientHints = z.infer<typeof webrtcClientHintsSchema>;
-export declare const webrtcCapability: {
-    readonly name: "webrtc";
-    readonly scope: "system";
-    readonly mode: "collection";
-    readonly internal: true;
-    readonly methods: {
-        readonly handleOffer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-            sdpOffer: z.ZodString;
-        }, z.core.$strip>, z.ZodString, "mutation">;
-        readonly supportsStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly registerStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-            codec: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly unregisterStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        /**
-         * Two-step server-offer signaling. `hints` is optional — providers
-         * that don't care about adaptive source selection ignore it.
-         */
-        readonly createSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-            hints: z.ZodOptional<z.ZodObject<{
-                viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-                viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-                devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-                downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-                prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>, z.ZodObject<{
-            sessionId: z.ZodString;
-            sdpOffer: z.ZodString;
-        }, z.core.$strip>, "mutation">;
-        readonly handleAnswer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            sessionId: z.ZodString;
-            sdpAnswer: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly closeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            sessionId: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        /**
-         * Whether this provider supports adaptive bitrate for the given stream.
-         * Currently always false — adaptive selection is one-shot at session
-         * start, not in-session encoder switching. Phase 5 plans to layer
-         * encoder-driven adaptation on top.
-         */
-        readonly hasAdaptiveBitrate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            streamId: z.ZodString;
-        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
-    };
-    /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-    readonly mount: {
-        readonly kind: "skip";
-    };
-};
-export type IWebrtcProvider = InferProvider<typeof webrtcCapability>;

package/dist/interfaces/restreamer.d.ts

@@ -1,23 +0,0 @@
-import type { EncodedPacket } from './stream-broker.js';
-export interface RegisteredStream {
-    readonly streamId: string;
-    readonly label: string;
-    readonly codec: string;
-    readonly type: 'video' | 'audio';
-    readonly sourceUrl?: string;
-}
-export interface RestreamerExposedResource {
-    readonly type: string;
-    readonly format: string;
-    readonly value: string;
-    readonly metadata?: Readonly<Record<string, unknown>>;
-}
-export interface IRestreamer {
-    readonly id: string;
-    readonly name: string;
-    registerDevice(deviceId: number, streams: readonly RegisteredStream[]): Promise<void>;
-    pushPacket(streamId: string, packet: EncodedPacket): void;
-    unregisterDevice(deviceId: number): Promise<void>;
-    getExposedResources(deviceId: number): readonly RestreamerExposedResource[];
-    proxyWhepOffer?(streamId: string, sdpOffer: string): Promise<string>;
-}

package/dist/interfaces/streaming.d.ts

@@ -1,28 +0,0 @@
-export type StreamFormat = 'webrtc' | 'hls' | 'mjpeg' | 'rtsp';
-export interface StreamingSource {
-    readonly url: string;
-    readonly protocol: 'rtsp' | 'http' | 'rtmp';
-    readonly deviceId: string;
-    readonly providerId: string;
-    readonly label?: string;
-}
-export interface StreamInfo {
-    readonly streamId: string;
-    readonly source: StreamingSource;
-    readonly formats: StreamFormat[];
-}
-export interface StreamStatus {
-    readonly active: boolean;
-    readonly viewers: number;
-    readonly startedAt?: number;
-}
-export interface IStreamingEngine {
-    initialize(config: Record<string, unknown>): Promise<void>;
-    shutdown(): Promise<void>;
-    registerStream(streamId: string, source: StreamingSource): Promise<void>;
-    unregisterStream(streamId: string): Promise<void>;
-    getStreamUrl(streamId: string, format: StreamFormat): string | null;
-    proxyWhepOffer(streamId: string, sdpOffer: string): Promise<string>;
-    listStreams(): StreamInfo[];
-    getStreamStatus(streamId: string): StreamStatus | null;
-}

package/dist/interfaces/webrtc-provider.d.ts

@@ -1,34 +0,0 @@
-import type { EncodedPacket } from './stream-broker.js';
-import type { WebrtcClientHints } from '../capabilities/webrtc.cap.js';
-export interface IWebRtcProvider {
-    readonly id: string;
-    readonly name: string;
-    handleOffer(streamId: string, sdpOffer: string): Promise<string>;
-    supportsStream(streamId: string): boolean;
-    registerStream(streamId: string, codec: string): Promise<void>;
-    pushPacket(streamId: string, packet: EncodedPacket): void;
-    unregisterStream(streamId: string): Promise<void>;
-    /**
-     * Server-offer signaling: create a session and return the server SDP
-     * offer. Single-object signature matches `InferProvider<>` so the
-     * generated cap-router can dispatch directly. `hints` is optional
-     * client metadata (viewport, downlink) the provider can use to pick
-     * the best native source.
-     */
-    createSession?(input: {
-        streamId: string;
-        hints?: WebrtcClientHints;
-    }): Promise<{
-        sessionId: string;
-        sdpOffer: string;
-    }>;
-    /** Server-offer signaling: accept the client SDP answer for a session. */
-    handleAnswer?(input: {
-        sessionId: string;
-        sdpAnswer: string;
-    }): Promise<void>;
-    /** Explicitly close a WebRTC session (called on client disconnect). */
-    closeSession?(input: {
-        sessionId: string;
-    }): Promise<void>;
-}