@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/server/run-driver.d.ts

@@ -0,0 +1,58 @@
+import { type LocalCoordinator } from '../coordinator/index.js';
+import { type AgentProfile } from '../agent/profiles.js';
+import type { AgentProvider } from '../agent/types.js';
+import type { FwMockConfig } from '../built-in-nodes/mock-types.js';
+import { type CallbackOutcome } from './callback-delivery.js';
+import type { CallbackPolicy } from './callback-url.js';
+import type { Json } from './respond.js';
+import type { ServerRequest, ServerResponse } from './transport.js';
+import type { RunResponse, WorkflowEndpoint } from './types.js';
+export interface RunDriverOptions {
+    /** The project: agent profiles are read from its `.flowweaver/agents.yaml`. */
+    dir: string;
+    coordinator: LocalCoordinator;
+    /** The function names of the workflows served here; the run list shows only their runs. */
+    workflowNames(): Set<string>;
+    /** Answer agent gates from the profiles. */
+    agents: boolean;
+    env?: NodeJS.ProcessEnv;
+    agentProvider?: (profile: AgentProfile, env: NodeJS.ProcessEnv) => AgentProvider;
+    trace?: boolean;
+    origin?: string;
+    maxInFlight: number;
+    onRun?: (run: RunResponse) => void;
+    /** Which URLs callbacks go to, and the token that signs them. */
+    callbacks?: CallbackPolicy;
+    token?: string;
+    onCallback?: (outcome: CallbackOutcome) => void;
+}
+export type RunDriver = ReturnType<typeof createRunDriver>;
+export declare function createRunDriver(opts: RunDriverOptions): {
+    callbacks: {
+        deliver: (id: string) => Promise<void>;
+        owe(id: string): void;
+        scan(workflowNames: ReadonlySet<string>): Promise<void>;
+        deliverPending(): Promise<void>;
+        pending: () => readonly string[];
+    };
+    admit: () => void;
+    start: (endpoint: WorkflowEndpoint, id: string, params: Json, mocks: FwMockConfig | undefined) => Promise<void>;
+    resume: (id: string, input: {
+        answer?: unknown;
+    } | {
+        reject: string;
+    }) => Promise<void>;
+    cancel: (id: string) => Promise<void>;
+    tick: () => Promise<void>;
+    snapshot: (id: string, base?: string) => Promise<RunResponse | undefined>;
+    listRuns: (workflow: string | undefined, base: string) => Promise<{
+        count: number;
+        runs: RunResponse[];
+    }>;
+    follow: (req: ServerRequest, res: ServerResponse, id: string, base: string) => Promise<void>;
+    /** The parameters of a run this process is driving, before the store has its record. */
+    inFlightParams: (id: string) => Json | undefined;
+    /** Stop what is in flight and end every stream. */
+    close(): void;
+};
+//# sourceMappingURL=run-driver.d.ts.map

package/dist/server/run-view.d.ts

@@ -0,0 +1,26 @@
+/**
+ * How a run reads from outside: the run resource built from its stored
+ * record and, while a segment is in flight here, from that segment; the
+ * data ports of a result without the control ports; and the HTTP status each
+ * state answers with on a run resource.
+ */
+import type { RunRecord } from '../coordinator/index.js';
+import type { RunResponse } from './types.js';
+import type { Json } from './respond.js';
+/** What a segment in flight here knows of its run before, or besides, the store. */
+export interface InFlightRun {
+    workflow: string;
+    params: Json;
+    startedAt: number;
+    error?: string;
+}
+/** The run resource, with links under `base`. Undefined when neither the store nor this process knows the run. */
+export declare function runView(id: string, base: string, l: InFlightRun | undefined, rec: RunRecord | undefined): RunResponse | undefined;
+/** The output ports of a completed run, without the control ports. */
+export declare function dataOf(result: unknown): {
+    data: Json;
+    failed: boolean;
+};
+/** The HTTP status a run's state reads as on a run resource. */
+export declare const statusFor: (run: RunResponse) => 200 | 500 | 202;
+//# sourceMappingURL=run-view.d.ts.map

package/dist/server/transport.d.ts

@@ -0,0 +1,35 @@
+/** What the handler reads from a request. Node's IncomingMessage is one, and so is the fetch shim below. */
+export interface ServerRequest {
+    method?: string;
+    url?: string;
+    headers: Record<string, string | string[] | undefined>;
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array | string>;
+    on(event: 'close', listener: () => void): unknown;
+    /**
+     * A body a framework already parsed (`express.json()`, `express.urlencoded()`
+     * set this). When present the stream is not read again, which it could not
+     * be anyway. A string or Buffer is parsed by the request's content type.
+     */
+    body?: unknown;
+}
+/** What the handler writes to a response. Node's ServerResponse is one. */
+export interface ServerResponse {
+    headersSent: boolean;
+    writeHead(status: number, headers?: Record<string, string | number>): unknown;
+    setHeader(name: string, value: string): unknown;
+    write(chunk: string): unknown;
+    end(chunk?: string): unknown;
+}
+type Handle = (req: ServerRequest, res: ServerResponse, opts?: {
+    basePath?: string;
+}) => Promise<boolean>;
+/**
+ * Run the handler against a Web Request, answering a Web Response. The
+ * response resolves as soon as headers are written, with a stream for the
+ * body, so server-sent events flow through hosts that support streaming.
+ */
+export declare function fetchAdapter(handle: Handle, request: Request, opts?: {
+    basePath?: string;
+}): Promise<Response>;
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/dist/server/types.d.ts

@@ -1,84 +1,154 @@
 /**
- * Type definitions for the webhook server
- */
-/**
- * Represents a workflow exposed as an HTTP endpoint
+ * Types for `fw serve`: workflows as HTTP endpoints, runs as resources.
  */
+import type { AgentNote } from '../coordinator/run-store.js';
+/** A workflow exposed as an HTTP endpoint. */
 export interface WorkflowEndpoint {
-    /** Workflow name (used in URL path) */
+    /** Workflow name (used in the URL). */
     name: string;
-    /** Function name in the source file */
+    /** Function name in the source file. */
     functionName: string;
-    /** Path to the source file */
+    /** Path to the source file. */
     filePath: string;
-    /** HTTP method for the endpoint */
+    /** HTTP method for the endpoint. */
     method: 'POST' | 'GET';
-    /** URL path for the endpoint */
+    /** URL path for the endpoint. */
     path: string;
-    /** JSON Schema for input parameters */
+    /** JSON Schema for the input parameters. */
     inputSchema?: Record<string, unknown>;
-    /** JSON Schema for output */
+    /** JSON Schema for the output. */
     outputSchema?: Record<string, unknown>;
-    /** Workflow description */
+    /** Workflow description. */
     description?: string;
+    /** How many durable gates the workflow declares. A gated workflow answers 202 and a run id. */
+    gates?: number;
+    /** The routes the workflow declares with `@http`, in order. */
+    routes?: import('../ast/types.js').THttpRoute[];
 }
-/**
- * Configuration for the webhook server
- */
+/** Configuration for the server. */
 export interface WebhookServerConfig {
-    /** Port to listen on */
     port: number;
-    /** Host to bind to */
     host: string;
-    /** Directory containing workflow files */
+    /** Directory containing the workflow files. It is also where `.flowweaver/agents.yaml` is looked for. */
     workflowDir: string;
-    /** Enable file watching for hot reload */
+    /** Re-discover workflows when files change. */
     watchEnabled: boolean;
-    /** CORS origin configuration */
-    corsOrigin: string | string[];
-    /** Production mode (no trace events) */
-    production: boolean;
-    /** Precompile workflows on startup */
-    precompile: boolean;
-    /** Enable Swagger UI at /docs and OpenAPI spec at /openapi.json */
+    /** CORS origin. Unset means no CORS headers are sent. */
+    corsOrigin?: string | string[];
+    /** Deprecated alias for `trace: false`. */
+    production?: boolean;
+    /** Accepted for compatibility. Workflows are compiled by the coordinator as they run. */
+    precompile?: boolean;
+    /** Serve Swagger UI at /docs. The spec at /openapi.json is always there. */
     swaggerEnabled?: boolean;
+    /** Bearer token every route except /health must carry. Unset means open. */
+    token?: string;
+    /** Answer agent gates from the project's agent profiles. Default true. */
+    agents?: boolean;
+    /** Keep a step trace for every run and stream it on /runs/:id/events. Default false. */
+    trace?: boolean;
+    /** Development conveniences: error stacks in responses, `mocks` accepted in a start body. */
+    dev?: boolean;
+    /** Where runs are stored. `fw serve` passes the project's `.fw/runs`; unset falls back to `~/.fw/runs`. */
+    runsDir?: string;
+    /** A run store of your own in place of the directory. */
+    store?: import('../coordinator/store.js').RunStore;
+    /** The environment agent profiles read their keys from. Defaults to `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Build the provider for a profile yourself -- an embedding's own client, or a test's fake. */
+    agentProvider?: (profile: import('../agent/profiles.js').AgentProfile, env: NodeJS.ProcessEnv) => import('../agent/types.js').AgentProvider;
+    /** Also mount every workflow at `POST /workflows/<name>`, declared or not. Default true. */
+    legacyRoutes?: boolean;
+    /** Which callback URLs are delivered to. Public hosts only by default. */
+    callbacks?: import('./callback-url.js').CallbackPolicy & {
+        sweepMs?: number;
+    };
+    /** The largest request body read. Default 1 MiB. */
+    maxBodyBytes?: number;
+    /** Segments started by requests that may run at once. Past it, 503. Default 32. */
+    maxInFlight?: number;
+    /** The longest a request waits for its segment before answering 202. Default 60 s. */
+    maxWaitMs?: number;
+    /** Every state change of a run, for logs and metrics. */
+    onRun?: (run: RunResponse) => void;
+    /** Every callback delivery attempt. */
+    onCallback?: (outcome: {
+        runId: string;
+        url: string;
+        ok: boolean;
+        status?: number;
+        error?: string;
+        attempt: number;
+        gaveUp?: boolean;
+    }) => void;
 }
-/**
- * Result of workflow execution via HTTP
- */
-export interface ExecutionResult {
-    /** Whether execution succeeded */
-    success: boolean;
-    /** Name of the executed workflow */
+/** A run as the API shows it. */
+export interface RunResponse {
+    runId: string;
     workflow: string;
-    /** Execution time in milliseconds */
-    executionTime: number;
-    /** Execution result (if successful) */
+    status: 'running' | 'waiting' | 'completed' | 'failed' | 'cancelled';
+    startedAt: string;
+    updatedAt: string;
+    params?: Record<string, unknown>;
+    /** Present while `waiting`: the gate and what it needs. */
+    gate?: {
+        id: string;
+        kind: 'approval' | 'input' | 'agent' | 'timer';
+        node: string;
+        inputs: Record<string, unknown>;
+        absent: string[];
+        outputs: string[];
+        hasFailurePort: boolean;
+    };
+    /**
+     * Present while `waiting` when the clock will move the run: a `timer` gate
+     * wakes (`wake`) at `at`, and a gate given a `timeout` takes its failure path
+     * (`timeout`) at `at`. The API's sweep does it, so nobody has to call resolve.
+     */
+    due?: {
+        at: string;
+        action: 'wake' | 'timeout';
+    };
+    /** What an agent profile is doing, or did, about the run's agent gate. */
+    agent?: AgentNote;
+    /** Present when `completed`. */
     result?: unknown;
-    /** Error details (if failed) */
-    error?: {
-        message: string;
-        stack?: string;
+    /** Present when `failed`. */
+    error?: ErrorDetail;
+    /** Milliseconds the answering segment took, on a synchronous start or resume. */
+    executionTime?: number;
+    /** Where to go next. */
+    links: {
+        self: string;
+        events: string;
+        result: string;
+        resolve?: string;
+        cancel?: string;
     };
-    /** Execution trace events (if requested) */
-    trace?: Array<{
-        type: string;
-        timestamp: number;
-        data?: unknown;
-    }>;
 }
-/**
- * Health check response
- */
+export interface ErrorDetail {
+    code: string;
+    message: string;
+    /** Field-level detail, such as which parameters were missing. */
+    details?: unknown;
+    stack?: string;
+}
+export interface ErrorBody {
+    error: ErrorDetail;
+}
+/** Health check response. */
 export interface HealthResponse {
     status: 'ok' | 'error';
     timestamp: string;
     workflows: number;
     uptime?: number;
+    version: string;
+    auth: 'token' | 'open';
+    agents: boolean;
+    /** Declared `@http` routes mounted. */
+    routes: number;
 }
-/**
- * Workflow list response
- */
+/** Workflow list response. */
 export interface WorkflowListResponse {
     count: number;
     workflows: Array<{
@@ -86,8 +156,29 @@ export interface WorkflowListResponse {
         path: string;
         method: string;
         description?: string;
+        gates?: number;
+        routes?: import('../ast/types.js').THttpRoute[];
         inputSchema?: Record<string, unknown>;
         outputSchema?: Record<string, unknown>;
     }>;
 }
+/**
+ * @deprecated The pre-0.39 execution response. `POST /workflows/:name` now
+ * answers with a `RunResponse`. Kept so older imports still compile.
+ */
+export interface ExecutionResult {
+    success: boolean;
+    workflow: string;
+    executionTime: number;
+    result?: unknown;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    trace?: Array<{
+        type: string;
+        timestamp: number;
+        data?: unknown;
+    }>;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/server/webhook-server.d.ts

@@ -1,50 +1,24 @@
-/**
- * Webhook server for exposing workflows as HTTP endpoints
- */
+import { type WorkflowApi } from './api.js';
 import type { WebhookServerConfig } from './types.js';
-/**
- * HTTP server that exposes Flow Weaver workflows as REST endpoints
- */
+export type { CallbackPolicy } from './callback-url.js';
 export declare class WebhookServer {
-    private fastify;
-    private registry;
+    private server;
+    readonly api: WorkflowApi;
     private config;
+    /** Where the server is listening, once it is. */
+    url: string;
     constructor(config: WebhookServerConfig);
-    /**
-     * Start the HTTP server
-     */
+    /** Start listening. `port: 0` picks a free one; `url` says which. */
     start(): Promise<void>;
-    /**
-     * Setup health check endpoint
-     */
-    private setupHealthRoute;
-    /**
-     * Setup workflow list endpoint
-     */
-    private setupListRoute;
-    /**
-     * Setup dynamic workflow execution route
-     */
-    private setupExecuteRoute;
-    /**
-     * Build OpenAPI spec from discovered workflows
-     */
-    private buildOpenApiSpec;
-    /**
-     * Setup Swagger UI and OpenAPI spec routes
-     */
-    private setupSwaggerRoutes;
-    /**
-     * Get server info for external logging
-     */
+    /** Stop listening, end every stream, and stop what is in flight. */
+    stop(): Promise<void>;
     getServerInfo(): {
         port: number;
         host: string;
         endpoints: number;
+        routes: number;
+        url: string;
     };
-    /**
-     * Stop the HTTP server
-     */
-    stop(): Promise<void>;
+    buildOpenApiSpec(): object;
 }
 //# sourceMappingURL=webhook-server.d.ts.map

package/dist/server/workflow-registry.d.ts

@@ -11,7 +11,6 @@ export declare class WorkflowRegistry {
     private endpoints;
     private watcher;
     private debounceTimers;
-    private parser;
     private startTime;
     constructor(workflowDir: string, options?: {
         precompile?: boolean;
@@ -34,7 +33,8 @@ export declare class WorkflowRegistry {
      */
     private extractOutputSchema;
     /**
-     * Convert Flow Weaver data type to JSON Schema type
+     * A Flow Weaver data type as a JSON Schema fragment. `ANY` has no JSON
+     * Schema type: it is the empty schema, which admits anything.
      */
     private dataTypeToJsonSchema;
     /**
@@ -50,9 +50,12 @@ export declare class WorkflowRegistry {
      */
     getUptime(): number;
     /**
-     * Start watching for file changes
+     * Start watching for file changes. After a change settles, the workflows
+     * are discovered again and `onChange` runs. A rediscovery that fails goes
+     * to `onError`, which by default writes it to stderr, and the next change
+     * tries again.
      */
-    startWatching(onChange: () => void): Promise<void>;
+    startWatching(onChange: () => void, onError?: (error: unknown) => void): Promise<void>;
     /**
      * Stop watching for file changes
      */

package/dist/service-registry.d.ts

@@ -0,0 +1,49 @@
+export type ServiceKind = 'mcp-server' | 'serve' | 'console';
+export interface ServiceRecord {
+    kind: ServiceKind;
+    pid: number;
+    /** Flow Weaver's version, and the install it runs from. */
+    version: string;
+    install: string;
+    /** Where it was started. */
+    cwd: string;
+    /** The project it serves, when that is not the working directory. */
+    project?: string;
+    url?: string;
+    transport?: 'stdio' | 'http';
+    /** What is on the other end, when known: the MCP client's name and version. */
+    client?: string;
+    startedAt: string;
+    lastActivityAt: string;
+    /** The last thing it did: a tool name, a request. */
+    activity?: string;
+    activityCount: number;
+}
+/** The package this module runs from: `dist/` or `src/` sits one level below it. */
+export declare function installRoot(): string;
+/** Whether a process exists. `EPERM` means it exists but is not ours. */
+export declare function isAlive(pid: number): boolean;
+export interface Announcement {
+    readonly file: string;
+    /** Note activity, at most one write a second. */
+    touch(activity?: string): void;
+    /** Change what is known about the service (its client, its project). */
+    update(patch: Partial<Pick<ServiceRecord, 'client' | 'project' | 'url'>>): void;
+    /** Withdraw the record. Also done on exit. */
+    retire(): void;
+}
+/**
+ * Announce this process. Best effort throughout: a service must never fail
+ * to start because its status directory could not be written.
+ */
+export declare function announceService(init: {
+    kind: ServiceKind;
+    cwd?: string;
+    project?: string;
+    url?: string;
+    transport?: 'stdio' | 'http';
+    dir?: string;
+}): Announcement;
+/** Every service alive now, newest first. Records of dead processes are removed as they are found. */
+export declare function listServices(dir?: string): ServiceRecord[];
+//# sourceMappingURL=service-registry.d.ts.map

package/dist/service-registry.js

@@ -0,0 +1,123 @@
+// src/service-registry.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/generated-version.ts
+var VERSION = "0.44.0";
+
+// src/service-registry.ts
+function servicesDir() {
+  return process.env.FW_SERVICES_DIR ?? path.join(os.homedir(), ".fw", "services");
+}
+function installRoot() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, file);
+}
+function announceService(init) {
+  const dir = init.dir ?? servicesDir();
+  const file = path.join(dir, `${init.kind}-${process.pid}.json`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let record = {
+    kind: init.kind,
+    pid: process.pid,
+    version: VERSION,
+    install: installRoot(),
+    cwd: init.cwd ?? process.cwd(),
+    project: init.project,
+    url: init.url,
+    transport: init.transport,
+    startedAt: now,
+    lastActivityAt: now,
+    activityCount: 0
+  };
+  const write = () => {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      writeAtomic(file, JSON.stringify(record));
+    } catch {
+    }
+  };
+  write();
+  let lastWrite = Date.now();
+  let pending;
+  const retire = () => {
+    if (pending) clearTimeout(pending);
+    try {
+      fs.rmSync(file, { force: true });
+    } catch {
+    }
+  };
+  process.once("exit", retire);
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.once(sig, () => {
+      retire();
+    });
+  }
+  return {
+    file,
+    touch(activity) {
+      record = { ...record, lastActivityAt: (/* @__PURE__ */ new Date()).toISOString(), activity: activity ?? record.activity, activityCount: record.activityCount + 1 };
+      const due = 1e3 - (Date.now() - lastWrite);
+      if (due <= 0) {
+        lastWrite = Date.now();
+        write();
+      } else if (!pending) pending = setTimeout(() => {
+        pending = void 0;
+        lastWrite = Date.now();
+        write();
+      }, due).unref?.();
+    },
+    update(patch) {
+      record = { ...record, ...patch };
+      write();
+    },
+    retire
+  };
+}
+function listServices(dir = servicesDir()) {
+  let names;
+  try {
+    names = fs.readdirSync(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const file = path.join(dir, name);
+    let record;
+    try {
+      record = JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!record || typeof record.pid !== "number" || !isAlive(record.pid)) {
+      try {
+        fs.rmSync(file, { force: true });
+      } catch {
+      }
+      continue;
+    }
+    out.push(record);
+  }
+  return out.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export {
+  announceService,
+  installRoot,
+  isAlive,
+  listServices
+};

package/dist/testing/assertions.d.ts

@@ -3,7 +3,7 @@
  *
  * Usage:
  * ```typescript
- * import { expectAgentResult } from 'flow-weaver/testing';
+ * import { expectAgentResult } from '@synergenius/flow-weaver/testing';
  *
  * const result = await myAgentWorkflow(true, { query: 'hello' });
  *
@@ -13,7 +13,7 @@
  *   .toNotHaveOutput('error');
  * ```
  */
-import type { MockLlmProvider } from './mock-llm.js';
+import type { MockLlmProvider } from './mock-llm';
 export interface AgentResultAssertions {
     /** Assert the workflow completed successfully (onSuccess === true) */
     toHaveSucceeded(): AgentResultAssertions;

package/dist/testing/index.d.ts

@@ -12,19 +12,20 @@
  *   expectAgentResult,
  *   expectMockLlm,
  *   TokenTracker,
- * } from 'flow-weaver/testing';
+ * } from '@synergenius/flow-weaver/testing';
  * ```
  */
-export { createMockLlmProvider } from './mock-llm.js';
-export type { MockLlmProvider, MockLlmResponse, MockLlmCall, LLMProvider, LLMMessage, LLMResponse, LLMToolCall, LLMTool, LLMTokenUsage, } from './mock-llm.js';
-export { expectAgentResult, expectMockLlm } from './assertions.js';
-export type { AgentResultAssertions, MockLlmAssertions } from './assertions.js';
-export { TokenTracker } from './token-tracker.js';
-export type { TrackedStep } from './token-tracker.js';
-export { createRecordingProvider } from './recorder.js';
-export type { RecordingLlmProvider, LlmRecording, LlmRecordingStep } from './recorder.js';
-export { createReplayProvider, loadRecording } from './replayer.js';
-export type { ReplayOptions } from './replayer.js';
-export { createMockApprovalProvider } from './mock-approval.js';
-export type { MockApprovalProvider, MockApprovalResponse, MockApprovalCall, ApprovalProvider, ApprovalRequest, ApprovalResult, } from './mock-approval.js';
+export { createMockLlmProvider } from './mock-llm';
+export type { MockLlmProvider, MockLlmResponse, MockLlmCall, LLMProvider, LLMMessage, LLMResponse, LLMToolCall, LLMTool, LLMTokenUsage, } from './mock-llm';
+export { expectAgentResult, expectMockLlm } from './assertions';
+export type { AgentResultAssertions, MockLlmAssertions } from './assertions';
+export { TokenTracker } from './token-tracker';
+export type { TrackedStep } from './token-tracker';
+export { createRecordingProvider } from './recorder';
+export type { RecordingLlmProvider, LlmRecording, LlmRecordingStep } from './recorder';
+export { createReplayProvider, loadRecording } from './replayer';
+export type { ReplayOptions } from './replayer';
+export { checkRunStore } from './run-store-check';
+export { createMockApprovalProvider } from './mock-approval';
+export type { MockApprovalProvider, MockApprovalResponse, MockApprovalCall, ApprovalProvider, ApprovalRequest, ApprovalResult, } from './mock-approval';
 //# sourceMappingURL=index.d.ts.map