streamby-core 0.28.4 → 0.28.6

package/dist/middleware/createRouter.js

@@ -24,6 +24,11 @@ const dbConnection_1 = require("./routes/dbConnection");
 const storageConnection_1 = require("./routes/storageConnection");
 const notification_1 = require("./routes/notification");
 const subscription_1 = require("./routes/subscription");
+const media_1 = require("./routes/media");
+const renderFarm_1 = require("./routes/renderFarm");
+const review_1 = require("./routes/review");
+const distribution_1 = require("./routes/distribution");
+const ai_1 = require("./routes/ai");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -39,6 +44,13 @@ function createStreamByRouter(config) {
         if (nosqlDbIds.length > 0) {
             (0, manager_1.registerModel)('notifications', nosqlDbIds, 'notifications', streambySchema);
             (0, manager_1.registerModel)('storage_files', nosqlDbIds, 'storage_files');
+            (0, manager_1.registerModel)('media_metadata', nosqlDbIds, 'media_metadata');
+            (0, manager_1.registerModel)('asset_versions', nosqlDbIds, 'asset_versions');
+            (0, manager_1.registerModel)('asset_dependency_graphs', nosqlDbIds, 'asset_dependency_graphs');
+            (0, manager_1.registerModel)('review_sessions', nosqlDbIds, 'review_sessions');
+            (0, manager_1.registerModel)('annotations', nosqlDbIds, 'annotations');
+            (0, manager_1.registerModel)('qc_reports', nosqlDbIds, 'qc_reports');
+            (0, manager_1.registerModel)('generative_jobs', nosqlDbIds, 'generative_jobs');
         }
         const mainDb = config.databases.find(db => db.main);
         if (mainDb) {
@@ -64,5 +76,10 @@ function createStreamByRouter(config) {
     router.use((0, storageConnection_1.storageConnectionRouter)(config));
     router.use((0, notification_1.notificationRouter)(config));
     router.use((0, subscription_1.subscriptionRouter)(config));
+    router.use((0, media_1.mediaRouter)(config));
+    router.use((0, renderFarm_1.renderFarmRouter)(config));
+    router.use((0, review_1.reviewRouter)(config));
+    router.use((0, distribution_1.distributionRouter)(config));
+    router.use((0, ai_1.aiRouter)(config));
     return router;
 }

package/dist/middleware/routes/ai.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function aiRouter(_config: StreamByConfig): Router;

package/dist/middleware/routes/ai.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiRouter = aiRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const aiProcessor_1 = require("../../services/aiProcessor");
+const AVAILABLE_NODE_TYPES = [
+    'dataSourceNode', 'jsonInputNode', 'apiConnectionNode',
+    'processNode', 'filterNode',
+    'ingestNode', 'transcodeNode', 'captionNode', 'thumbnailNode',
+    'renderJobNode', 'formatConvertNode', 'lodNode', 'assetDependencyNode',
+    'reviewGateNode', 'annotationNode',
+    'qcCheckNode', 'deliverableNode', 'distributionNode',
+    'transcriptionNode', 'upscaleNode', 'proceduralAssetNode', 'pipelineSuggestNode',
+];
+function aiRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // POST /projects/:projectId/jobs/transcription
+    router.post('/projects/:projectId/jobs/transcription', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, model, sourceLanguage, outputFormats, provider, credentialId } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('transcription', auth.userId, projectId, { fileId, model, sourceLanguage, outputFormats, provider, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, { model, sourceLanguage, outputFormats, provider, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/upscale
+    router.post('/projects/:projectId/jobs/upscale', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, scale, model, mode, credentialId } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('upscale', auth.userId, projectId, { fileId, scale, model, mode, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, { scale, model, mode, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/generate-asset
+    router.post('/projects/:projectId/jobs/generate-asset', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetType, provider, prompt, seed, credentialId } = req.body;
+            if (!prompt)
+                return res.status(400).json({ message: 'prompt is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('generate-asset', auth.userId, projectId, { assetType, provider, prompt, seed, credentialId });
+            setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, { assetType, provider, prompt, seed, credentialId }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/pipeline-suggest
+    router.post('/projects/:projectId/pipeline-suggest', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { nodeSchema } = req.body;
+            if (!nodeSchema?.nodes)
+                return res.status(400).json({ message: 'nodeSchema is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const suggestion = await (0, aiProcessor_1.buildPipelineSuggestion)(nodeSchema, AVAILABLE_NODE_TYPES);
+            res.json({ suggestion });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/distribution.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function distributionRouter(_config: StreamByConfig): Router;

package/dist/middleware/routes/distribution.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distributionRouter = distributionRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const wsHub_1 = require("../../services/wsHub");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const crypto_1 = __importDefault(require("crypto"));
+function getDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}
+function broadcastDeliveryUpdate(userId, payload) {
+    (0, wsHub_1.emitToUser)(userId, { type: 'jobEvent', data: payload });
+}
+function distributionRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const Export = (0, manager_1.getModel)('exports');
+    // ─── Distribution Connections ─────────────────────────────────────────────────
+    router.get('/projects/:projectId/distribution-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            res.json({ connections: project.distributionConnections ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/distribution-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, target, credentialId, config, description } = req.body;
+            if (!name || !target)
+                return res.status(400).json({ message: 'name and target are required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const connection = {
+                id: crypto_1.default.randomUUID(),
+                name,
+                target,
+                credentialId,
+                config: config ?? {},
+                description,
+                projectId,
+                createdAt: new Date(),
+            };
+            await Project.update({ _id: projectId }, { $push: { distributionConnections: connection } });
+            res.status(201).json({ connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/distribution-connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connectionId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            await Project.update({ _id: projectId }, { $pull: { distributionConnections: { id: connectionId } } });
+            res.json({ message: 'Connection deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Publish Deliverable ──────────────────────────────────────────────────────
+    router.post('/projects/:projectId/deliverables/:exportId/publish', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, exportId } = req.params;
+            const { targets } = req.body;
+            if (!targets?.length)
+                return res.status(400).json({ message: 'targets array is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const exportDoc = await Export.findOne({ id: exportId, projectId });
+            if (!exportDoc)
+                return res.status(404).json({ message: 'Deliverable not found' });
+            const connections = project.distributionConnections ?? [];
+            const deliveryTargets = targets.map(t => {
+                const conn = connections.find(c => c.id === t.connectionId);
+                return {
+                    connectionId: t.connectionId,
+                    target: conn?.target ?? 'customWebhook',
+                    channel: t.channel,
+                    status: 'pending',
+                };
+            });
+            const now = new Date();
+            await Export.update({ id: exportId, projectId }, {
+                $set: {
+                    deliverableTargets: deliveryTargets,
+                    publishedAt: now,
+                    publishedBy: auth.userId,
+                    updatedAt: now,
+                },
+            });
+            // Dispatch async — actual upload/API call happens in the host worker
+            setImmediate(() => {
+                for (const dt of deliveryTargets) {
+                    broadcastDeliveryUpdate(auth.userId, {
+                        jobId: crypto_1.default.randomUUID(),
+                        jobType: 'distribute',
+                        stage: 'queued',
+                        progress: 5,
+                        assetId: exportId,
+                        message: `Queued publish to ${dt.target}`,
+                    });
+                }
+            });
+            res.status(202).json({ deliverableTargets: deliveryTargets, publishedAt: now });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── QC Reports ───────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:assetId/qc-report', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const report = await db.collection('qc_reports').findOne({ assetId, projectId }, { sort: { generatedAt: -1 } });
+            res.json({ report: report ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/assets/:assetId/qc-report', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId } = req.params;
+            const { checks } = req.body;
+            if (!Array.isArray(checks))
+                return res.status(400).json({ message: 'checks array is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const overallPassed = checks.every((c) => c.passed === true);
+            const report = {
+                assetId,
+                projectId,
+                checks,
+                overallPassed,
+                generatedAt: new Date(),
+            };
+            await db.collection('qc_reports').insertOne({ ...report });
+            res.status(201).json({ report });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/media.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import { StreamByConfig, StorageAdapter } from '../../types';
+export declare function mediaRouter(config: StreamByConfig & {
+    adapter?: StorageAdapter;
+}): Router;

package/dist/middleware/routes/media.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaRouter = mediaRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const mediaProcessor_1 = require("../../services/mediaProcessor");
+const storage_1 = require("../../providers/storage");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+function getMetadataCollection() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db().collection('media_metadata');
+}
+function getVersionsCollection() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db().collection('asset_versions');
+}
+function mediaRouter(config) {
+    const router = (0, express_1.Router)();
+    const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /jobs/:jobId — poll job status
+    router.get('/jobs/:jobId', (req, res) => {
+        const job = (0, jobQueue_1.getJob)(req.params.jobId);
+        if (!job)
+            return res.status(404).json({ message: 'Job not found' });
+        res.json({ job });
+    });
+    // POST /projects/:projectId/jobs/ingest — queue an ingest job for an already-uploaded file
+    router.post('/projects/:projectId/jobs/ingest', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('ingest', auth.userId, projectId, { fileId });
+            // Run async — response returns immediately with jobId
+            setImmediate(() => (0, mediaProcessor_1.runIngestJob)(job.jobId, fileId, projectId));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/transcode
+    router.post('/projects/:projectId/jobs/transcode', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, codec, resolution, outputFormat, bitrate, audioCodec } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('transcode', auth.userId, projectId, {
+                fileId, codec, resolution, outputFormat, bitrate, audioCodec,
+            });
+            setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, { codec, resolution, outputFormat, bitrate, audioCodec }, adapter));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/thumbnail
+    router.post('/projects/:projectId/jobs/thumbnail', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, timecode, resolution, strategy } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('thumbnail', auth.userId, projectId, { fileId, timecode, resolution, strategy });
+            setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, { timecode, resolution, strategy }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/jobs/caption
+    router.post('/projects/:projectId/jobs/caption', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, sourceLanguage, outputFormat, provider } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('caption', auth.userId, projectId, { fileId, sourceLanguage, outputFormat, provider });
+            setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, { sourceLanguage, outputFormat, provider }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/assets/:fileId/metadata
+    router.get('/projects/:projectId/assets/:fileId/metadata', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getMetadataCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            const meta = await col.findOne({ assetId: fileId, projectId });
+            res.json({ metadata: meta ?? null });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // PATCH /projects/:projectId/assets/:fileId/metadata — update custom tags
+    router.patch('/projects/:projectId/assets/:fileId/metadata', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const { customTags } = req.body;
+            if (!customTags || typeof customTags !== 'object') {
+                return res.status(400).json({ message: 'customTags object is required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getMetadataCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            await col.updateOne({ assetId: fileId, projectId }, { $set: { customTags, updatedAt: new Date() } }, { upsert: true });
+            res.json({ message: 'Metadata updated' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/assets/:fileId/versions
+    router.get('/projects/:projectId/assets/:fileId/versions', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const col = getVersionsCollection();
+            if (!col)
+                return res.status(500).json({ message: 'Database not available' });
+            const versions = await col
+                .find({ assetId: fileId, projectId })
+                .sort({ version: -1 })
+                .toArray();
+            res.json({ versions });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/renderFarm.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function renderFarmRouter(_config: StreamByConfig): Router;