@hasna/testers 0.0.4 → 0.0.6

package/dist/server/index.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env bun
 // @bun
-
-// src/server/index.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/types/index.ts
-var MODEL_MAP = {
-  quick: "claude-haiku-4-5-20251001",
-  thorough: "claude-sonnet-4-6-20260311",
-  deep: "claude-opus-4-6-20260311"
-};
 function scenarioFromRow(row) {
   return {
     id: row.id,
@@ -103,39 +104,61 @@ function scheduleFromRow(row) {
     updatedAt: row.updated_at
   };
 }
-class VersionConflictError extends Error {
-  constructor(entity, id) {
-    super(`Version conflict on ${entity}: ${id}`);
-    this.name = "VersionConflictError";
-  }
-}
-
-class BrowserError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserError";
-  }
-}
-
-class AIClientError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AIClientError";
-  }
-}
-class ScheduleNotFoundError extends Error {
-  constructor(id) {
-    super(`Schedule not found: ${id}`);
-    this.name = "ScheduleNotFoundError";
-  }
+function flowFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    name: row.name,
+    description: row.description,
+    scenarioIds: JSON.parse(row.scenario_ids),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
 }
+var MODEL_MAP, VersionConflictError, BrowserError, AIClientError, ScheduleNotFoundError, DependencyCycleError;
+var init_types = __esm(() => {
+  MODEL_MAP = {
+    quick: "claude-haiku-4-5-20251001",
+    thorough: "claude-sonnet-4-6-20260311",
+    deep: "claude-opus-4-6-20260311"
+  };
+  VersionConflictError = class VersionConflictError extends Error {
+    constructor(entity, id) {
+      super(`Version conflict on ${entity}: ${id}`);
+      this.name = "VersionConflictError";
+    }
+  };
+  BrowserError = class BrowserError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BrowserError";
+    }
+  };
+  AIClientError = class AIClientError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "AIClientError";
+    }
+  };
+  ScheduleNotFoundError = class ScheduleNotFoundError extends Error {
+    constructor(id) {
+      super(`Schedule not found: ${id}`);
+      this.name = "ScheduleNotFoundError";
+    }
+  };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    constructor(scenarioId, dependsOn) {
+      super(`Adding dependency ${dependsOn} to ${scenarioId} would create a cycle`);
+      this.name = "DependencyCycleError";
+    }
+  };
+});
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
 import { mkdirSync, existsSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
-var db = null;
 function now() {
   return new Date().toISOString();
 }
@@ -154,8 +177,50 @@ function resolveDbPath() {
     mkdirSync(dir, { recursive: true });
   return join(dir, "testers.db");
 }
-var MIGRATIONS = [
-  `
+function applyMigrations(database) {
+  const applied = database.query("SELECT id FROM _migrations ORDER BY id").all();
+  const appliedIds = new Set(applied.map((r) => r.id));
+  for (let i = 0;i < MIGRATIONS.length; i++) {
+    const migrationId = i + 1;
+    if (appliedIds.has(migrationId))
+      continue;
+    const migration = MIGRATIONS[i];
+    database.exec(migration);
+    database.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(migrationId, now());
+  }
+}
+function getDatabase() {
+  if (db)
+    return db;
+  const dbPath = resolveDbPath();
+  const dir = dirname(dbPath);
+  if (dbPath !== ":memory:" && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  applyMigrations(db);
+  return db;
+}
+function resolvePartialId(table, partialId) {
+  const database = getDatabase();
+  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? || '%'`).all(partialId);
+  if (rows.length === 1)
+    return rows[0].id;
+  return null;
+}
+var db = null, MIGRATIONS;
+var init_database = __esm(() => {
+  MIGRATIONS = [
+    `
   CREATE TABLE IF NOT EXISTS projects (
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL UNIQUE,
@@ -244,7 +309,7 @@ var MIGRATIONS = [
     applied_at TEXT NOT NULL DEFAULT (datetime('now'))
   );
   `,
-  `
+    `
   CREATE INDEX IF NOT EXISTS idx_scenarios_project ON scenarios(project_id);
   CREATE INDEX IF NOT EXISTS idx_scenarios_priority ON scenarios(priority);
   CREATE INDEX IF NOT EXISTS idx_scenarios_short_id ON scenarios(short_id);
@@ -255,11 +320,11 @@ var MIGRATIONS = [
   CREATE INDEX IF NOT EXISTS idx_results_status ON results(status);
   CREATE INDEX IF NOT EXISTS idx_screenshots_result ON screenshots(result_id);
   `,
-  `
+    `
   ALTER TABLE projects ADD COLUMN scenario_prefix TEXT DEFAULT 'TST';
   ALTER TABLE projects ADD COLUMN scenario_counter INTEGER DEFAULT 0;
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS schedules (
     id TEXT PRIMARY KEY,
     project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
@@ -283,12 +348,12 @@ var MIGRATIONS = [
   CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
   CREATE INDEX IF NOT EXISTS idx_schedules_next_run ON schedules(next_run_at);
   `,
-  `
+    `
   ALTER TABLE screenshots ADD COLUMN description TEXT;
   ALTER TABLE screenshots ADD COLUMN page_url TEXT;
   ALTER TABLE screenshots ADD COLUMN thumbnail_path TEXT;
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS auth_presets (
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL UNIQUE,
@@ -299,7 +364,7 @@ var MIGRATIONS = [
     created_at TEXT NOT NULL DEFAULT (datetime('now'))
   );
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS webhooks (
     id TEXT PRIMARY KEY,
     url TEXT NOT NULL,
@@ -310,50 +375,191 @@ var MIGRATIONS = [
     created_at TEXT NOT NULL DEFAULT (datetime('now'))
   );
   CREATE INDEX IF NOT EXISTS idx_webhooks_active ON webhooks(active);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS scenario_dependencies (
+    scenario_id TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    PRIMARY KEY (scenario_id, depends_on),
+    CHECK (scenario_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS flows (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    scenario_ids TEXT NOT NULL DEFAULT '[]',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_deps_scenario ON scenario_dependencies(scenario_id);
+  CREATE INDEX IF NOT EXISTS idx_deps_depends ON scenario_dependencies(depends_on);
+  CREATE INDEX IF NOT EXISTS idx_flows_project ON flows(project_id);
   `
-];
-function applyMigrations(database) {
-  const applied = database.query("SELECT id FROM _migrations ORDER BY id").all();
-  const appliedIds = new Set(applied.map((r) => r.id));
-  for (let i = 0;i < MIGRATIONS.length; i++) {
-    const migrationId = i + 1;
-    if (appliedIds.has(migrationId))
+  ];
+});
+
+// src/db/flows.ts
+var exports_flows = {};
+__export(exports_flows, {
+  topologicalSort: () => topologicalSort,
+  removeDependency: () => removeDependency,
+  listFlows: () => listFlows,
+  getTransitiveDependencies: () => getTransitiveDependencies,
+  getFlow: () => getFlow,
+  getDependents: () => getDependents,
+  getDependencies: () => getDependencies,
+  deleteFlow: () => deleteFlow,
+  createFlow: () => createFlow,
+  addDependency: () => addDependency
+});
+function addDependency(scenarioId, dependsOn) {
+  const db2 = getDatabase();
+  const visited = new Set;
+  const queue = [dependsOn];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === scenarioId) {
+      throw new DependencyCycleError(scenarioId, dependsOn);
+    }
+    if (visited.has(current))
       continue;
-    const migration = MIGRATIONS[i];
-    database.exec(migration);
-    database.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(migrationId, now());
+    visited.add(current);
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    for (const dep of deps) {
+      if (!visited.has(dep.depends_on)) {
+        queue.push(dep.depends_on);
+      }
+    }
   }
+  db2.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
 }
-function getDatabase() {
-  if (db)
-    return db;
-  const dbPath = resolveDbPath();
-  const dir = dirname(dbPath);
-  if (dbPath !== ":memory:" && !existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+function removeDependency(scenarioId, dependsOn) {
+  const db2 = getDatabase();
+  const result = db2.query("DELETE FROM scenario_dependencies WHERE scenario_id = ? AND depends_on = ?").run(scenarioId, dependsOn);
+  return result.changes > 0;
+}
+function getDependencies(scenarioId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(scenarioId);
+  return rows.map((r) => r.depends_on);
+}
+function getDependents(scenarioId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT scenario_id FROM scenario_dependencies WHERE depends_on = ?").all(scenarioId);
+  return rows.map((r) => r.scenario_id);
+}
+function getTransitiveDependencies(scenarioId) {
+  const db2 = getDatabase();
+  const visited = new Set;
+  const queue = [scenarioId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    for (const dep of deps) {
+      if (!visited.has(dep.depends_on)) {
+        visited.add(dep.depends_on);
+        queue.push(dep.depends_on);
+      }
+    }
   }
-  db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec("PRAGMA busy_timeout = 5000");
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS _migrations (
-      id INTEGER PRIMARY KEY,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-  applyMigrations(db);
-  return db;
+  return Array.from(visited);
 }
-function resolvePartialId(table, partialId) {
-  const database = getDatabase();
-  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? || '%'`).all(partialId);
-  if (rows.length === 1)
-    return rows[0].id;
+function topologicalSort(scenarioIds) {
+  const db2 = getDatabase();
+  const idSet = new Set(scenarioIds);
+  const inDegree = new Map;
+  const dependents = new Map;
+  for (const id of scenarioIds) {
+    inDegree.set(id, 0);
+    dependents.set(id, []);
+  }
+  for (const id of scenarioIds) {
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(id);
+    for (const dep of deps) {
+      if (idSet.has(dep.depends_on)) {
+        inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+        dependents.get(dep.depends_on).push(id);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0)
+      queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const dep of dependents.get(current) ?? []) {
+      const newDeg = (inDegree.get(dep) ?? 1) - 1;
+      inDegree.set(dep, newDeg);
+      if (newDeg === 0)
+        queue.push(dep);
+    }
+  }
+  if (sorted.length !== scenarioIds.length) {
+    throw new DependencyCycleError("multiple", "multiple");
+  }
+  return sorted;
+}
+function createFlow(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO flows (id, project_id, name, description, scenario_ids, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.projectId ?? null, input.name, input.description ?? null, JSON.stringify(input.scenarioIds), timestamp, timestamp);
+  return getFlow(id);
+}
+function getFlow(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM flows WHERE id = ?").get(id);
+  if (row)
+    return flowFromRow(row);
+  const fullId = resolvePartialId("flows", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM flows WHERE id = ?").get(fullId);
+    if (row)
+      return flowFromRow(row);
+  }
   return null;
 }
+function listFlows(projectId) {
+  const db2 = getDatabase();
+  if (projectId) {
+    const rows2 = db2.query("SELECT * FROM flows WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+    return rows2.map(flowFromRow);
+  }
+  const rows = db2.query("SELECT * FROM flows ORDER BY created_at DESC").all();
+  return rows.map(flowFromRow);
+}
+function deleteFlow(id) {
+  const db2 = getDatabase();
+  const flow = getFlow(id);
+  if (!flow)
+    return false;
+  const result = db2.query("DELETE FROM flows WHERE id = ?").run(flow.id);
+  return result.changes > 0;
+}
+var init_flows = __esm(() => {
+  init_database();
+  init_database();
+  init_types();
+});
+
+// src/server/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 
 // src/db/scenarios.ts
+init_types();
+init_database();
 function nextShortId(projectId) {
   const db2 = getDatabase();
   if (projectId) {
@@ -517,6 +723,8 @@ function deleteScenario(id) {
 }
 
 // src/db/runs.ts
+init_types();
+init_database();
 function createRun(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -629,6 +837,8 @@ function updateRun(id, updates) {
 }
 
 // src/db/results.ts
+init_types();
+init_database();
 function createResult(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -705,6 +915,8 @@ function getResultsByRun(runId) {
 }
 
 // src/db/screenshots.ts
+init_types();
+init_database();
 function createScreenshot(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -728,6 +940,7 @@ function listScreenshots(resultId) {
 
 // src/lib/browser.ts
 import { chromium } from "playwright";
+init_types();
 var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
 async function launchBrowser(options) {
   const headless = options?.headless ?? true;
@@ -947,6 +1160,7 @@ class Screenshotter {
 }
 
 // src/lib/ai-client.ts
+init_types();
 import Anthropic from "@anthropic-ai/sdk";
 function resolveModel(nameOrPreset) {
   if (nameOrPreset in MODEL_MAP) {
@@ -1499,7 +1713,8 @@ async function runAgentLoop(options) {
     screenshotter,
     model,
     runId,
-    maxTurns = 30
+    maxTurns = 30,
+    onStep
   } = options;
   const systemPrompt = [
     "You are an expert QA testing agent. Your job is to thoroughly test web application scenarios.",
@@ -1558,8 +1773,8 @@ async function runAgentLoop(options) {
       }
       const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
       if (toolUseBlocks.length === 0 && response.stop_reason === "end_turn") {
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        const textReasoning = textBlocks.map((b) => b.text).join(`
+        const textBlocks2 = response.content.filter((block) => block.type === "text");
+        const textReasoning = textBlocks2.map((b) => b.text).join(`
 `);
         return {
           status: "error",
@@ -1570,10 +1785,22 @@ async function runAgentLoop(options) {
         };
       }
       const toolResults = [];
+      const textBlocks = response.content.filter((block) => block.type === "text");
+      if (textBlocks.length > 0 && onStep) {
+        const thinking = textBlocks.map((b) => b.text).join(`
+`);
+        onStep({ type: "thinking", thinking, stepNumber });
+      }
       for (const toolBlock of toolUseBlocks) {
         stepNumber++;
         const toolInput = toolBlock.input;
+        if (onStep) {
+          onStep({ type: "tool_call", toolName: toolBlock.name, toolInput, stepNumber });
+        }
         const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber });
+        if (onStep) {
+          onStep({ type: "tool_result", toolName: toolBlock.name, toolResult: execResult.result, stepNumber });
+        }
         if (execResult.screenshot) {
           screenshots.push({
             ...execResult.screenshot,
@@ -1625,6 +1852,7 @@ function createClient(apiKey) {
 }
 
 // src/lib/config.ts
+init_types();
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 import { readFileSync, existsSync as existsSync3 } from "fs";
@@ -1715,7 +1943,20 @@ async function runSingleScenario(scenario, runId, options) {
       screenshotter,
       model,
       runId,
-      maxTurns: 30
+      maxTurns: 30,
+      onStep: (stepEvent) => {
+        emit({
+          type: `step:${stepEvent.type}`,
+          scenarioId: scenario.id,
+          scenarioName: scenario.name,
+          runId,
+          toolName: stepEvent.toolName,
+          toolInput: stepEvent.toolInput,
+          toolResult: stepEvent.toolResult,
+          thinking: stepEvent.thinking,
+          stepNumber: stepEvent.stepNumber
+        });
+      }
     });
     for (const ss of agentResult.screenshots) {
       createScreenshot({
@@ -1768,24 +2009,70 @@ async function runBatch(scenarios, options) {
     projectId: options.projectId
   });
   updateRun(run.id, { status: "running", total: scenarios.length });
+  let sortedScenarios = scenarios;
+  try {
+    const { topologicalSort: topologicalSort2 } = await Promise.resolve().then(() => (init_flows(), exports_flows));
+    const scenarioIds = scenarios.map((s) => s.id);
+    const sortedIds = topologicalSort2(scenarioIds);
+    const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+    sortedScenarios = sortedIds.map((id) => scenarioMap.get(id)).filter((s) => s !== undefined);
+    for (const s of scenarios) {
+      if (!sortedIds.includes(s.id))
+        sortedScenarios.push(s);
+    }
+  } catch {}
   const results = [];
+  const failedScenarioIds = new Set;
+  const canRun = async (scenario) => {
+    try {
+      const { getDependencies: getDependencies2 } = await Promise.resolve().then(() => (init_flows(), exports_flows));
+      const deps = getDependencies2(scenario.id);
+      for (const depId of deps) {
+        if (failedScenarioIds.has(depId))
+          return false;
+      }
+    } catch {}
+    return true;
+  };
   if (parallel <= 1) {
-    for (const scenario of scenarios) {
+    for (const scenario of sortedScenarios) {
+      if (!await canRun(scenario)) {
+        const result2 = createResult({ runId: run.id, scenarioId: scenario.id, model, stepsTotal: 0 });
+        const skipped = updateResult(result2.id, { status: "skipped", error: "Skipped: dependency failed" });
+        results.push(skipped);
+        failedScenarioIds.add(scenario.id);
+        emit({ type: "scenario:error", scenarioId: scenario.id, scenarioName: scenario.name, error: "Dependency failed \u2014 skipped", runId: run.id });
+        continue;
+      }
       const result = await runSingleScenario(scenario, run.id, options);
       results.push(result);
+      if (result.status === "failed" || result.status === "error") {
+        failedScenarioIds.add(scenario.id);
+      }
     }
   } else {
-    const queue = [...scenarios];
+    const queue = [...sortedScenarios];
     const running = [];
     const processNext = async () => {
       const scenario = queue.shift();
       if (!scenario)
         return;
+      if (!await canRun(scenario)) {
+        const result2 = createResult({ runId: run.id, scenarioId: scenario.id, model, stepsTotal: 0 });
+        const skipped = updateResult(result2.id, { status: "skipped", error: "Skipped: dependency failed" });
+        results.push(skipped);
+        failedScenarioIds.add(scenario.id);
+        await processNext();
+        return;
+      }
       const result = await runSingleScenario(scenario, run.id, options);
       results.push(result);
+      if (result.status === "failed" || result.status === "error") {
+        failedScenarioIds.add(scenario.id);
+      }
       await processNext();
     };
-    const workers = Math.min(parallel, scenarios.length);
+    const workers = Math.min(parallel, sortedScenarios.length);
     for (let i = 0;i < workers; i++) {
       running.push(processNext());
     }
@@ -1835,7 +2122,14 @@ function estimateCost(model, tokens) {
   return tokens / 1e6 * costPer1M * 100;
 }
 
+// src/server/index.ts
+init_types();
+init_database();
+
 // src/db/schedules.ts
+init_database();
+init_types();
+init_database();
 function createSchedule(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -1962,6 +2256,7 @@ function updateLastRun(id, runId, nextRunAt) {
 }
 
 // src/lib/scheduler.ts
+init_types();
 function parseCronField(field, min, max) {
   const results = new Set;
   const parts = field.split(",");

package/dist/types/index.d.ts

@@ -359,4 +359,35 @@ export declare class AgentNotFoundError extends Error {
 export declare class ScheduleNotFoundError extends Error {
     constructor(id: string);
 }
+export declare class FlowNotFoundError extends Error {
+    constructor(id: string);
+}
+export declare class DependencyCycleError extends Error {
+    constructor(scenarioId: string, dependsOn: string);
+}
+export interface FlowRow {
+    id: string;
+    project_id: string | null;
+    name: string;
+    description: string | null;
+    scenario_ids: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface Flow {
+    id: string;
+    projectId: string | null;
+    name: string;
+    description: string | null;
+    scenarioIds: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function flowFromRow(row: FlowRow): Flow;
+export interface CreateFlowInput {
+    name: string;
+    description?: string;
+    scenarioIds: string[];
+    projectId?: string;
+}
 //# sourceMappingURL=index.d.ts.map