streamby-core 0.25.8 → 0.26.0

package/dist/adapters/database/sql.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sqlAdapter = exports.createSQLRawExportTable = exports.createSQLExportTable = void 0;
+const crypto_1 = require("crypto");
 const createSQLExportTable = async (connection, projectId, exportName, fields) => {
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const tableName = `export_${projectId}_${slug}`;
     const columns = fields.map(field => `"${field.name}" ${field.type}`).join(',');
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      "projectId" UUID NOT NULL,
-      __metadata JSONB NOT NULL,
-      ${columns ? `, ${columns}` : ''}
-    );
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      "projectId" UUID NOT NULL,
+      __metadata JSONB NOT NULL,
+      ${columns ? `, ${columns}` : ''}
+    );
   `;
     await connection.query(createTableQuery);
     console.log(`✅ Table '${tableName}' created with metadata.`);
@@ -26,21 +27,24 @@ const createSQLExportTable = async (connection, projectId, exportName, fields) =
     return { collectionName: tableName, exportId: tableName };
 };
 exports.createSQLExportTable = createSQLExportTable;
-const createSQLRawExportTable = async (connection, projectId, exportName, jsonData) => {
+const createSQLRawExportTable = async (connection, exportName, nodeSchema) => {
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const tableName = `raw_export_${projectId}_${slug}`;
-    const createTableQuery = `
-    CREATE TABLE IF NOT EXISTS "${tableName}" (
-      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-      data JSONB NOT NULL
-    );
+    const tableName = slug;
+    const exportId = (0, crypto_1.randomUUID)();
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      node_schema JSONB,
+      name TEXT,
+      method TEXT,
+      created_at TIMESTAMPTZ DEFAULT NOW(),
+      updated_at TIMESTAMPTZ DEFAULT NOW()
+    );
   `;
     await connection.query(createTableQuery);
+    await connection.query(`INSERT INTO "${tableName}" (id, node_schema, name, method) VALUES ($1, $2, $3, $4)`, [exportId, nodeSchema ? JSON.stringify(nodeSchema) : null, exportName, 'GET']);
     console.log(`✅ Raw table '${tableName}' created.`);
-    // Insert the raw JSON data directly into the new table
-    await connection.query(`INSERT INTO "${tableName}" (data) VALUES ($1)`, [jsonData]);
-    console.log(`✅ Raw JSON data inserted into table '${tableName}'.`);
-    return { collectionName: tableName, exportId: tableName };
+    return { collectionName: tableName, exportId };
 };
 exports.createSQLRawExportTable = createSQLRawExportTable;
 exports.sqlAdapter = {

package/dist/middleware/createRouter.js

@@ -14,7 +14,7 @@ const storage_2 = require("./routes/storage");
 const project_1 = require("./routes/project");
 const export_1 = require("./routes/export");
 const credential_1 = require("./routes/credential");
-const apiConnection_1 = require("./routes/apiConnection");
+const connection_1 = require("./routes/connection");
 const member_1 = require("./routes/member");
 const user_1 = require("./routes/user");
 const auth_2 = require("../services/auth");
@@ -43,7 +43,7 @@ function createStreamByRouter(config) {
     router.use((0, project_1.projectRouter)(config));
     router.use((0, export_1.exportRouter)(config));
     router.use((0, credential_1.credentialRouter)(config));
-    router.use((0, apiConnection_1.apiConnectionRouter)(config));
+    router.use((0, connection_1.apiConnectionRouter)(config));
     router.use((0, member_1.memberRouter)(config));
     router.use((0, user_1.userRouter)(config));
     return router;

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

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

package/dist/middleware/routes/connection.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiConnectionRouter = apiConnectionRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const apiConnection_1 = require("../../services/apiConnection");
+const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
+function apiConnectionRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // List API connections for a project
+    router.get('/projects/:id/connections/api', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            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 project access' });
+            }
+            return res.status(200).json({ data: project.apiConnections || [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch API connections', details: err.message });
+        }
+    });
+    // Add a new API connection to a project
+    router.post('/projects/:id/connections/api', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { name, baseUrl, method, description, credentialId, prefix } = req.body;
+            if (!name || !baseUrl) {
+                return res.status(400).json({ message: 'name and baseUrl are required' });
+            }
+            if (!VALID_METHODS.includes(method)) {
+                return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.join(', ')}` });
+            }
+            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 project access' });
+            }
+            if (credentialId) {
+                const credExists = project.credentials?.some((c) => c.id === credentialId);
+                if (!credExists) {
+                    return res.status(400).json({ message: 'Credential not found in project' });
+                }
+            }
+            const connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
+                name,
+                baseUrl,
+                method,
+                prefix,
+                ...(description !== undefined && { description }),
+                ...(credentialId !== undefined && { credentialId }),
+            });
+            return res.status(201).json({ data: connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add API connection', details: err.message });
+        }
+    });
+    // Execute the request represented by an API connection
+    router.get('/projects/:id/get-connection/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { id: 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 project access' });
+            }
+            const apiConnection = project.apiConnections?.find((c) => c.id === connectionId);
+            if (!apiConnection) {
+                return res.status(404).json({ message: 'API connection not found' });
+            }
+            const headers = { 'Content-Type': 'application/json' };
+            if (apiConnection.credentialId) {
+                const { decrypt, isEncryptionKeySet } = await Promise.resolve().then(() => __importStar(require('../../utils/encryption')));
+                if (!isEncryptionKeySet()) {
+                    return res.status(500).json({ message: 'Encryption key is not set' });
+                }
+                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
+                if (!credential) {
+                    return res.status(400).json({ message: 'Credential not found in project' });
+                }
+                const decrypted = decrypt(credential.encryptedValue);
+                const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
+                headers['Authorization'] = `${prefix}${decrypted}`;
+            }
+            const response = await fetch(apiConnection.baseUrl, { method: apiConnection.method || 'GET', headers });
+            if (!response.ok) {
+                return res.status(response.status).json({ message: `External API error: ${response.statusText}` });
+            }
+            const data = await response.json();
+            return res.status(200).json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch connection data', details: err.message });
+        }
+    });
+    // Delete an API connection from a project
+    router.delete('/projects/:id/connections/api/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { 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 project access' });
+            }
+            const exists = project.apiConnections?.some((c) => c.id === connectionId);
+            if (!exists) {
+                return res.status(404).json({ message: 'API connection not found' });
+            }
+            await (0, apiConnection_1.deleteApiConnection)(config, projectId, connectionId);
+            return res.status(200).json({ message: 'API connection deleted successfully.' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete API connection', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/export.js

@@ -5,6 +5,7 @@ const express_1 = require("express");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
+const pipeline_1 = require("../../services/pipeline");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const mongodb_1 = require("mongodb");
 const encryption_1 = require("../../utils/encryption");
@@ -40,7 +41,18 @@ function exportRouter(config) {
             let data;
             if (project.dbType === 'nosql') {
                 const db = connection.client.db();
-                if (exportMetadata.type === 'json') {
+                if (exportMetadata.nodeSchema) {
+                    data = {
+                        name: exportMetadata.name,
+                        description: exportMetadata.description,
+                        collectionName: exportMetadata.collectionName,
+                        nodeSchema: exportMetadata.nodeSchema,
+                        useConnections: exportMetadata.useConnections,
+                        useCredentials: exportMetadata.useCredentials,
+                        type: exportMetadata.type,
+                    };
+                }
+                else if (exportMetadata.type === 'json') {
                     const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportId) });
                     data = {
                         json: rawData?.json,
@@ -146,23 +158,19 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = req.params.id;
-            const { name, description, fields, collectionName, jsonData, isPrivate, allowedOrigin, exportType, apiUrl, credentialId, prefix } = req.body;
-            if (!name || !collectionName) {
-                return res.status(400).json({ message: 'Missing export name or collectionName' });
+            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
+            if (!name) {
+                return res.status(400).json({ message: 'Missing export name' });
             }
-            if (exportType === 'externalApi') {
-                if (!apiUrl) {
-                    return res.status(400).json({ message: 'API URL is required for externalApi export type' });
-                }
-            }
-            else if (!jsonData) {
-                return res.status(400).json({ message: 'Missing jsonData for non-externalApi export types' });
+            if (!nodeSchema) {
+                return res.status(400).json({ message: 'Missing nodeSchema' });
             }
+            const exportType = useConnections ? 'externalApi' : 'json';
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const result = await (0, export_1.createExport)(config, projectId, description, fields, name, jsonData, project.dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix);
+            const result = await (0, export_1.createExport)(config, projectId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
             res.status(201).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -176,23 +184,23 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const { id: projectId, export_id: exportId } = req.params;
-            const { name, collectionName, description, fields, jsonData, isPrivate, allowedOrigin, exportType, apiUrl, credentialId, prefix } = req.body;
-            if (!name || !collectionName) {
-                return res.status(400).json({ message: 'Missing name or collectionName' });
-            }
-            if (exportType === 'externalApi') {
-                if (!apiUrl) {
-                    return res.status(400).json({ message: 'API URL is required for externalApi export type' });
-                }
+            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
+            if (!name) {
+                return res.status(400).json({ message: 'Missing name' });
             }
-            else if (!jsonData) {
-                return res.status(400).json({ message: 'Missing jsonData for non-externalApi export types' });
+            if (!nodeSchema) {
+                return res.status(400).json({ message: 'Missing nodeSchema' });
             }
+            const exportType = useConnections ? 'externalApi' : 'json';
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const result = await (0, export_1.updateExport)(config, projectId, exportId, description, fields, name, collectionName, jsonData, project.dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix);
+            const exportMetadata = project.exports?.find((e) => e.id.toString() === exportId);
+            if (!exportMetadata) {
+                return res.status(404).json({ message: 'Export not found' });
+            }
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, description, name, exportMetadata.name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -214,7 +222,7 @@ function exportRouter(config) {
             if (!exportMetadata) {
                 return res.status(404).json({ message: 'Export not found in this project' });
             }
-            await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType, exportMetadata.collectionName);
+            await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType, exportMetadata.name);
             res.status(200).json({ message: 'Export deleted successfully' });
         }
         catch (err) {
@@ -257,59 +265,63 @@ function exportRouter(config) {
             if (!isAllowed) {
                 return res.status(403).json({ message: 'Unauthorized' });
             }
-            const targetDb = config.databases?.find(db => db.type === project.dbType);
-            if (!targetDb) {
-                return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
-            }
-            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
             let data;
-            if (project.dbType === 'nosql') {
-                const db = connection.client.db();
-                if (exportMetadata.type === 'json') {
-                    const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
-                    data = rawData ? rawData.json : null;
+            if (exportMetadata.nodeSchema) {
+                data = await (0, pipeline_1.executePipeline)(exportMetadata.nodeSchema, project, config);
+            }
+            else {
+                const targetDb = config.databases?.find(db => db.type === project.dbType);
+                if (!targetDb) {
+                    return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
                 }
-                else if (exportMetadata.type === 'externalApi') {
-                    let headers = {};
-                    if (exportMetadata.credentialId) {
-                        if (!(0, encryption_1.isEncryptionKeySet)()) {
-                            throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
+                const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+                if (project.dbType === 'nosql') {
+                    const db = connection.client.db();
+                    if (exportMetadata.type === 'json') {
+                        const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
+                        data = rawData ? rawData.json : null;
+                    }
+                    else if (exportMetadata.type === 'externalApi') {
+                        let headers = {};
+                        if (exportMetadata.credentialId) {
+                            if (!(0, encryption_1.isEncryptionKeySet)()) {
+                                throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
+                            }
+                            const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
+                            if (!credential) {
+                                throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
+                            }
+                            const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
+                            const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
+                            headers = {
+                                'Authorization': `${authPrefix}${decryptedValue}`,
+                                'Content-Type': 'application/json',
+                            };
                         }
-                        const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
-                        if (!credential) {
-                            throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
+                        try {
+                            const response = await fetch(exportMetadata.apiUrl, { headers });
+                            if (!response.ok) {
+                                throw new Error(`Failed to fetch from external API: ${response.statusText}`);
+                            }
+                            data = await response.json();
                         }
-                        const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
-                        const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
-                        headers = {
-                            'Authorization': `${authPrefix}${decryptedValue}`,
-                            'Content-Type': 'application/json',
-                        };
-                    }
-                    try {
-                        const response = await fetch(exportMetadata.apiUrl, { headers });
-                        if (!response.ok) {
-                            throw new Error(`Failed to fetch from external API: ${response.statusText}`);
+                        catch (error) {
+                            throw new Error(`Error fetching from external API: ${error.message}`);
+                        }
+                        if (exportMetadata.fields && exportMetadata.fields.length > 0) {
+                            data = data.map((item) => {
+                                return exportMetadata.fields.reduce((filtered, field) => {
+                                    filtered[field.name] = item[field.name];
+                                    return filtered;
+                                }, {});
+                            });
                         }
-                        data = await response.json();
-                    }
-                    catch (error) {
-                        throw new Error(`Error fetching from external API: ${error.message}`);
-                    }
-                    if (exportMetadata.fields && exportMetadata.fields.length > 0) {
-                        data = data.map((item) => {
-                            return exportMetadata.fields.reduce((filtered, field) => {
-                                filtered[field.name] = item[field.name];
-                                return filtered;
-                            }, {});
-                        });
                     }
                 }
-            }
-            else if (project.dbType === 'sql') {
-                // SQL implementation for public exports will go here
-                return res.status(501).json({ message: 'SQL public exports not yet implemented' });
-            }
+                else if (project.dbType === 'sql') {
+                    return res.status(501).json({ message: 'SQL public exports not yet implemented' });
+                }
+            } // end legacy else block
             if (!data) {
                 return res.status(404).json({ message: 'Export data not found' });
             }

package/dist/middleware/routes/project.js

@@ -96,7 +96,16 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            res.json({ project: { ...project, id: project._id || project.id, _id: undefined, apiConnections: project.apiConnections || [] }, message: 'Project fetched successfully' });
+            const exports = (project.exports || []).map((e) => ({
+                id: e.id,
+                name: e.name,
+                description: e.description,
+                method: e.method,
+                private: e.private,
+                useConnections: e.useConnections,
+                useCredentials: e.useCredentials,
+            }));
+            res.json({ project: { ...project, id: project._id || project.id, _id: undefined, apiConnections: project.apiConnections || [], exports }, message: 'Project fetched successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch project', details: err.message });

package/dist/models/Model.js

@@ -45,11 +45,11 @@ class Model {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
-            FROM "${schema}"."projects" p
-            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
+            FROM "${schema}"."projects" p
+            JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
           `;
                     const result = await connection.query(query, [userId]);
                     sqlResults = result.rows.map(row => ({

package/dist/services/export.d.ts

@@ -1,12 +1,11 @@
-import { FieldDefinition, DatabaseType, StreamByConfig } from '../types';
-interface CreateExportResult {
+import { NodeSchema, DatabaseType, StreamByConfig } from '../types';
+interface ExportResult {
     exportId: string;
-    collectionName: string;
     message: string;
 }
-export declare function createExport(config: StreamByConfig, projectId: string, description: string, fields: FieldDefinition[], exportName: string, jsonData: any, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], apiUrl?: string, credentialId?: string, prefix?: string): Promise<CreateExportResult>;
-export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, fields: FieldDefinition[], exportName: string, collectionName: string, jsonData: any, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], apiUrl?: string, credentialId?: string, prefix?: string): Promise<CreateExportResult>;
-export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, collectionName: string): Promise<{
+export declare function createExport(config: StreamByConfig, projectId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
+export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, storedExportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
+export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, exportName: string): Promise<{
     message: string;
 }>;
 export {};