flowforge-client 0.1.2

package/dist/index.d.mts

@@ -0,0 +1,908 @@
+/**
+ * FlowForge TypeScript Client - Type Definitions
+ */
+type Result<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: FlowForgeError;
+};
+declare class FlowForgeError extends Error {
+    status: number;
+    code?: string | undefined;
+    detail?: unknown | undefined;
+    constructor(message: string, status: number, code?: string | undefined, detail?: unknown | undefined);
+}
+type RunStatus = "pending" | "running" | "completed" | "failed" | "paused" | "cancelled";
+type StepType = "run" | "sleep" | "ai" | "wait_for_event" | "invoke" | "send_event" | "agent";
+type StepStatus = "pending" | "running" | "completed" | "failed" | "sleeping" | "waiting";
+type TriggerType = "event" | "cron" | "webhook";
+type ApprovalStatus = "pending" | "approved" | "rejected" | "expired";
+interface Run {
+    id: string;
+    function_id: string;
+    event_id: string | null;
+    status: RunStatus;
+    trigger_type: string;
+    trigger_data: Record<string, unknown>;
+    output: Record<string, unknown> | null;
+    error: Record<string, unknown> | null;
+    attempt: number;
+    max_attempts: number;
+    started_at: string | null;
+    ended_at: string | null;
+    created_at: string;
+}
+interface Step {
+    id: string;
+    step_id: string;
+    step_type: StepType;
+    status: StepStatus;
+    input: Record<string, unknown> | null;
+    output: Record<string, unknown> | null;
+    error: Record<string, unknown> | null;
+    attempt: number;
+    max_attempts: number;
+    started_at: string | null;
+    ended_at: string | null;
+    created_at: string;
+}
+interface RunWithSteps extends Run {
+    steps: Step[];
+}
+interface FlowForgeFunction {
+    id: string;
+    function_id: string;
+    name: string;
+    trigger_type: TriggerType;
+    trigger_value: string;
+    trigger_expression: string | null;
+    endpoint_url: string | null;
+    is_inline: boolean;
+    system_prompt: string | null;
+    tools_config: string[] | null;
+    agent_config: Record<string, unknown> | null;
+    config: Record<string, unknown>;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface Tool {
+    id: string;
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    code: string | null;
+    is_builtin: boolean;
+    requires_approval: boolean;
+    approval_timeout: string | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface Event {
+    id: string;
+    event_id: string;
+    name: string;
+    data: Record<string, unknown>;
+    timestamp: string;
+    received_at: string;
+    user_id: string | null;
+    processed: boolean;
+}
+interface SendEventResponse extends Event {
+    runs: Array<{
+        id: string;
+        function_id: string;
+    }>;
+}
+interface Approval {
+    id: string;
+    tool_call_id: string;
+    tool_name: string;
+    arguments: Record<string, unknown>;
+    run_id: string;
+    step_id: string;
+    status: ApprovalStatus;
+    created_at: string;
+    timeout_at: string;
+}
+interface Stats {
+    runs: {
+        total: number;
+        completed: number;
+        failed: number;
+        running: number;
+    };
+    functions: {
+        total: number;
+        active: number;
+    };
+    events: {
+        today: number;
+        total: number;
+    };
+    queue: {
+        pending: number;
+        running: number;
+        scheduled: number;
+    };
+}
+interface HealthStatus {
+    status: "healthy" | "unhealthy";
+    version?: string;
+    uptime?: number;
+}
+interface RunFilters {
+    status: RunStatus;
+    function_id: string;
+}
+interface FunctionFilters {
+    trigger_type: TriggerType;
+    is_active: boolean;
+}
+interface EventFilters {
+    name: string;
+    processed: boolean;
+}
+interface ToolFilters {
+    is_active: boolean;
+    requires_approval: boolean;
+    is_builtin: boolean;
+}
+interface ApprovalFilters {
+    status: ApprovalStatus;
+}
+interface CreateFunctionInput {
+    id: string;
+    name: string;
+    trigger_type: TriggerType;
+    trigger_value: string;
+    trigger_expression?: string;
+    endpoint_url?: string;
+    is_inline?: boolean;
+    system_prompt?: string;
+    tools_config?: string[];
+    agent_config?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+    is_active?: boolean;
+}
+interface UpdateFunctionInput {
+    name?: string;
+    trigger_value?: string;
+    trigger_expression?: string;
+    endpoint_url?: string;
+    system_prompt?: string;
+    tools_config?: string[];
+    agent_config?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+    is_active?: boolean;
+}
+interface CreateToolInput {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    code?: string;
+    requires_approval?: boolean;
+    approval_timeout?: string;
+    is_active?: boolean;
+}
+interface UpdateToolInput {
+    description?: string;
+    parameters?: Record<string, unknown>;
+    code?: string;
+    requires_approval?: boolean;
+    approval_timeout?: string;
+    is_active?: boolean;
+}
+interface SendEventInput {
+    id?: string;
+    user_id?: string;
+    timestamp?: string;
+}
+type UserRole = "admin" | "member" | "viewer";
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    role: UserRole;
+    is_active: boolean;
+    last_login_at: string | null;
+    created_at: string;
+}
+interface CreateUserInput {
+    email: string;
+    password: string;
+    name: string;
+    role: UserRole;
+}
+interface UpdateUserInput {
+    email?: string;
+    name?: string;
+    role?: UserRole;
+    is_active?: boolean;
+}
+interface UsersResponse {
+    users: User[];
+    total: number;
+}
+type ApiKeyType = "live" | "test" | "ro";
+interface ApiKey {
+    id: string;
+    name: string;
+    key_prefix: string;
+    key_type: ApiKeyType;
+    scopes: string[];
+    expires_at: string | null;
+    last_used_at: string | null;
+    is_active: boolean;
+    created_at: string;
+}
+interface ApiKeyCreated extends ApiKey {
+    key: string;
+}
+interface CreateApiKeyInput {
+    name: string;
+    key_type?: ApiKeyType;
+    scopes?: string[];
+    expires_in_days?: number;
+}
+interface ApiKeysResponse {
+    keys: ApiKey[];
+    total: number;
+}
+interface ApiKeyFilters {
+    include_revoked: boolean;
+}
+interface ClientOptions {
+    /**
+     * API key for authentication.
+     * Uses the X-FlowForge-API-Key header.
+     * Format: ff_{type}_{random} (e.g., ff_live_a1b2c3d4...)
+     *
+     * Key types:
+     * - ff_live_xxx - Production keys with full access
+     * - ff_test_xxx - Test/development keys
+     * - ff_ro_xxx   - Read-only keys
+     */
+    apiKey?: string;
+    /** Custom fetch implementation (for testing or custom environments) */
+    fetch?: typeof fetch;
+}
+
+/**
+ * FlowForge TypeScript Client - Query Builder
+ *
+ * Generic, type-safe query builder with chainable methods.
+ */
+
+type OrderDirection = "asc" | "desc";
+interface QueryParams {
+    filters: Record<string, unknown>;
+    orderBy?: string;
+    orderDir?: OrderDirection;
+    limitValue?: number;
+    offsetValue?: number;
+}
+type RequestFn$2 = <T>(method: string, path: string, body?: unknown) => Promise<Result<T>>;
+/**
+ * Generic query builder for type-safe filtering and pagination.
+ *
+ * @example
+ * ```ts
+ * const { data } = await builder
+ *   .eq('status', 'completed')
+ *   .order('created_at', 'desc')
+ *   .limit(10)
+ *   .execute();
+ * ```
+ */
+declare class QueryBuilder<T, Filters> {
+    protected request: RequestFn$2;
+    protected basePath: string;
+    protected responseKey: string;
+    protected params: QueryParams;
+    constructor(request: RequestFn$2, basePath: string, responseKey: string);
+    /**
+     * Filter by exact match.
+     */
+    eq<K extends keyof Filters>(field: K, value: Filters[K]): this;
+    /**
+     * Order results by a field.
+     */
+    order<K extends keyof T>(field: K, direction?: OrderDirection): this;
+    /**
+     * Limit the number of results.
+     */
+    limit(n: number): this;
+    /**
+     * Skip the first n results (for pagination).
+     */
+    offset(n: number): this;
+    /**
+     * Build query string from params.
+     */
+    protected buildQueryString(): string;
+    /**
+     * Execute the query and return multiple results.
+     */
+    execute(): Promise<Result<T[]>>;
+    /**
+     * Execute the query and return a single result.
+     * Returns an error if no results found.
+     */
+    single(): Promise<Result<T>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Events Resource
+ */
+
+declare class EventsResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Send an event to trigger matching workflows.
+     *
+     * @example
+     * ```ts
+     * const { data, error } = await ff.events.send('order/created', {
+     *   order_id: '123',
+     *   customer: 'Alice'
+     * });
+     * if (error) console.error(error.message);
+     * else console.log('Triggered runs:', data.runs);
+     * ```
+     */
+    send(name: string, data: Record<string, unknown>, options?: SendEventInput): Promise<Result<SendEventResponse>>;
+    /**
+     * Get a specific event by ID.
+     *
+     * @example
+     * ```ts
+     * const { data: event } = await ff.events.get('event-id');
+     * ```
+     */
+    get(eventId: string): Promise<Result<Event>>;
+    /**
+     * Start building a query to select events.
+     *
+     * @example
+     * ```ts
+     * const { data: events } = await ff.events
+     *   .select()
+     *   .eq('name', 'order/*')
+     *   .limit(10)
+     *   .execute();
+     * ```
+     */
+    select(): QueryBuilder<Event, EventFilters>;
+}
+
+/**
+ * FlowForge TypeScript Client - Runs Resource
+ */
+
+declare class RunsResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Get a run by ID, including its steps.
+     *
+     * @example
+     * ```ts
+     * const { data: run } = await ff.runs.get('run-id');
+     * console.log(run.status, run.steps);
+     * ```
+     */
+    get(runId: string): Promise<Result<RunWithSteps>>;
+    /**
+     * Start building a query to select runs.
+     *
+     * @example
+     * ```ts
+     * const { data: runs } = await ff.runs
+     *   .select()
+     *   .eq('status', 'completed')
+     *   .order('created_at', 'desc')
+     *   .limit(10)
+     *   .execute();
+     * ```
+     */
+    select(): QueryBuilder<Run, RunFilters>;
+    /**
+     * Cancel a running workflow.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.runs.cancel('run-id');
+     * if (error) console.error('Failed to cancel:', error.message);
+     * ```
+     */
+    cancel(runId: string): Promise<Result<{
+        success: boolean;
+        message: string;
+    }>>;
+    /**
+     * Replay a completed or failed run.
+     *
+     * @example
+     * ```ts
+     * const { data: newRun } = await ff.runs.replay('run-id');
+     * console.log('New run ID:', newRun.id);
+     * ```
+     */
+    replay(runId: string): Promise<Result<RunWithSteps>>;
+    /**
+     * Wait for a run to complete (polling).
+     *
+     * @example
+     * ```ts
+     * const { data: completedRun, error } = await ff.runs.waitFor('run-id', {
+     *   timeout: 60000
+     * });
+     * if (error) console.error('Timeout or error:', error.message);
+     * else console.log('Run completed with status:', completedRun.status);
+     * ```
+     */
+    waitFor(runId: string, options?: {
+        timeout?: number;
+        interval?: number;
+    }): Promise<Result<RunWithSteps>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Functions Resource
+ */
+
+declare class FunctionsResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Get a function by ID.
+     *
+     * @example
+     * ```ts
+     * const { data: fn } = await ff.functions.get('my-function');
+     * console.log(fn.name, fn.is_active);
+     * ```
+     */
+    get(functionId: string): Promise<Result<FlowForgeFunction>>;
+    /**
+     * Start building a query to select functions.
+     *
+     * @example
+     * ```ts
+     * const { data: fns } = await ff.functions
+     *   .select()
+     *   .eq('is_active', true)
+     *   .eq('trigger_type', 'event')
+     *   .execute();
+     * ```
+     */
+    select(): QueryBuilder<FlowForgeFunction, FunctionFilters>;
+    /**
+     * Create a new function.
+     *
+     * @example
+     * ```ts
+     * const { data: fn, error } = await ff.functions.create({
+     *   id: 'order-processor',
+     *   name: 'Order Processor',
+     *   trigger_type: 'event',
+     *   trigger_value: 'order/created',
+     *   endpoint_url: 'http://localhost:3000/api/workflows/order',
+     * });
+     * ```
+     */
+    create(input: CreateFunctionInput): Promise<Result<FlowForgeFunction>>;
+    /**
+     * Update an existing function.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.functions.update('my-function', {
+     *   is_active: false
+     * });
+     * ```
+     */
+    update(functionId: string, input: UpdateFunctionInput): Promise<Result<FlowForgeFunction>>;
+    /**
+     * Delete a function.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.functions.delete('my-function');
+     * if (error) console.error('Failed to delete:', error.message);
+     * ```
+     */
+    delete(functionId: string): Promise<Result<{
+        success: boolean;
+        message: string;
+    }>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Tools Resource
+ */
+
+declare class ToolsResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Get a tool by name.
+     *
+     * @example
+     * ```ts
+     * const { data: tool } = await ff.tools.get('send-email');
+     * console.log(tool.description, tool.requires_approval);
+     * ```
+     */
+    get(toolName: string): Promise<Result<Tool>>;
+    /**
+     * Start building a query to select tools.
+     *
+     * @example
+     * ```ts
+     * const { data: tools } = await ff.tools
+     *   .select()
+     *   .eq('requires_approval', true)
+     *   .eq('is_active', true)
+     *   .execute();
+     * ```
+     */
+    select(): QueryBuilder<Tool, ToolFilters>;
+    /**
+     * Create a new tool.
+     *
+     * @example
+     * ```ts
+     * const { data: tool, error } = await ff.tools.create({
+     *   name: 'send-email',
+     *   description: 'Send an email to a recipient',
+     *   parameters: {
+     *     type: 'object',
+     *     properties: {
+     *       to: { type: 'string', description: 'Recipient email' },
+     *       subject: { type: 'string', description: 'Email subject' },
+     *       body: { type: 'string', description: 'Email body' },
+     *     },
+     *     required: ['to', 'subject', 'body'],
+     *   },
+     *   requires_approval: true,
+     * });
+     * ```
+     */
+    create(input: CreateToolInput): Promise<Result<Tool>>;
+    /**
+     * Update an existing tool.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.tools.update('send-email', {
+     *   requires_approval: false
+     * });
+     * ```
+     */
+    update(toolName: string, input: UpdateToolInput): Promise<Result<Tool>>;
+    /**
+     * Delete a tool.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.tools.delete('my-tool');
+     * if (error) console.error('Failed to delete:', error.message);
+     * ```
+     */
+    delete(toolName: string): Promise<Result<{
+        success: boolean;
+        message: string;
+    }>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Approvals Resource
+ *
+ * Human-in-the-loop approval management for tool calls.
+ */
+
+declare class ApprovalsResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Get an approval by ID.
+     *
+     * @example
+     * ```ts
+     * const { data: approval } = await ff.approvals.get('approval-id');
+     * console.log(approval.tool_name, approval.status);
+     * ```
+     */
+    get(approvalId: string): Promise<Result<Approval>>;
+    /**
+     * Start building a query to select approvals.
+     *
+     * @example
+     * ```ts
+     * const { data: pending } = await ff.approvals
+     *   .select()
+     *   .eq('status', 'pending')
+     *   .execute();
+     * ```
+     */
+    select(): QueryBuilder<Approval, ApprovalFilters>;
+    /**
+     * Approve a pending tool call.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.approvals.approve('approval-id');
+     * if (error) console.error('Failed to approve:', error.message);
+     * ```
+     *
+     * @example With modified arguments
+     * ```ts
+     * const { error } = await ff.approvals.approve('approval-id', {
+     *   modifiedArguments: { amount: 50 } // Override the original amount
+     * });
+     * ```
+     */
+    approve(approvalId: string, options?: {
+        modifiedArguments?: Record<string, unknown>;
+    }): Promise<Result<{
+        success: boolean;
+        message: string;
+    }>>;
+    /**
+     * Reject a pending tool call.
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.approvals.reject('approval-id', 'Too risky');
+     * if (error) console.error('Failed to reject:', error.message);
+     * ```
+     */
+    reject(approvalId: string, reason: string): Promise<Result<{
+        success: boolean;
+        message: string;
+    }>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Health Resource
+ */
+
+declare class HealthResource {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * Check if the server is healthy.
+     *
+     * @example
+     * ```ts
+     * const { data: healthy, error } = await ff.health.check();
+     * if (healthy) console.log('Server is healthy');
+     * else console.error('Server is unhealthy:', error?.message);
+     * ```
+     */
+    check(): Promise<Result<boolean>>;
+    /**
+     * Get server statistics.
+     *
+     * @example
+     * ```ts
+     * const { data: stats } = await ff.health.stats();
+     * console.log('Total runs:', stats.runs.total);
+     * console.log('Active functions:', stats.functions.active);
+     * ```
+     */
+    stats(): Promise<Result<Stats>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Users Resource
+ *
+ * Note: The SDK uses API key authentication only (X-FlowForge-API-Key header).
+ * User/password login is only available through the dashboard.
+ */
+
+type RequestFn$1 = <T>(method: string, path: string, body?: unknown) => Promise<Result<T>>;
+/**
+ * Users resource for user management (admin API key required).
+ *
+ * Note: This resource requires an admin-level API key.
+ * User/password login is only available through the dashboard.
+ */
+declare class UsersResource {
+    private request;
+    constructor(request: RequestFn$1);
+    /**
+     * List all users (admin only).
+     *
+     * @param options - Filter options
+     * @returns List of users
+     *
+     * @example
+     * ```ts
+     * const { data } = await ff.users.list({ includeInactive: true });
+     * console.log('Total users:', data?.total);
+     * ```
+     */
+    list(options?: {
+        includeInactive?: boolean;
+    }): Promise<Result<UsersResponse>>;
+    /**
+     * Get a user by ID (admin only).
+     *
+     * @param userId - User ID
+     * @returns User details
+     */
+    get(userId: string): Promise<Result<User>>;
+    /**
+     * Create a new user (admin only).
+     *
+     * @param input - User details
+     * @returns Created user
+     *
+     * @example
+     * ```ts
+     * const { data, error } = await ff.users.create({
+     *   email: 'user@example.com',
+     *   password: 'securepassword',
+     *   name: 'John Doe',
+     *   role: 'member'
+     * });
+     * ```
+     */
+    create(input: CreateUserInput): Promise<Result<User>>;
+    /**
+     * Update a user (admin only).
+     *
+     * @param userId - User ID
+     * @param input - Fields to update
+     * @returns Updated user
+     */
+    update(userId: string, input: UpdateUserInput): Promise<Result<User>>;
+    /**
+     * Delete a user (admin only).
+     *
+     * @param userId - User ID
+     * @returns Success message
+     */
+    delete(userId: string): Promise<Result<{
+        message: string;
+    }>>;
+}
+
+/**
+ * FlowForge TypeScript Client - API Keys Resource
+ */
+
+type RequestFn = <T>(method: string, path: string, body?: unknown) => Promise<Result<T>>;
+/**
+ * API Keys resource for managing API key authentication.
+ */
+declare class ApiKeysResource {
+    private request;
+    constructor(request: RequestFn);
+    /**
+     * List all API keys for the tenant.
+     *
+     * @param options - Filter options
+     * @returns List of API keys (without the actual key values)
+     *
+     * @example
+     * ```ts
+     * const { data } = await ff.apiKeys.list();
+     * data?.keys.forEach(key => {
+     *   console.log(`${key.name}: ${key.key_prefix}... (${key.key_type})`);
+     * });
+     * ```
+     */
+    list(options?: {
+        includeRevoked?: boolean;
+    }): Promise<Result<ApiKeysResponse>>;
+    /**
+     * Get an API key by ID.
+     *
+     * @param keyId - API key ID
+     * @returns API key details (without the actual key value)
+     */
+    get(keyId: string): Promise<Result<ApiKey>>;
+    /**
+     * Create a new API key.
+     *
+     * @param input - API key configuration
+     * @returns Created API key WITH the actual key value (only returned once!)
+     *
+     * @example
+     * ```ts
+     * const { data, error } = await ff.apiKeys.create({
+     *   name: 'Production API Key',
+     *   key_type: 'live',
+     *   scopes: ['events:send', 'runs:read']
+     * });
+     *
+     * if (data) {
+     *   // IMPORTANT: Store this key - it won't be shown again!
+     *   console.log('New API key:', data.key);  // ff_live_a1b2c3...
+     * }
+     * ```
+     */
+    create(input: CreateApiKeyInput): Promise<Result<ApiKeyCreated>>;
+    /**
+     * Revoke an API key.
+     *
+     * @param keyId - API key ID
+     * @param reason - Optional reason for revocation
+     * @returns Success message
+     *
+     * @example
+     * ```ts
+     * const { error } = await ff.apiKeys.revoke('key-id', 'Compromised');
+     * if (!error) {
+     *   console.log('Key revoked successfully');
+     * }
+     * ```
+     */
+    revoke(keyId: string, reason?: string): Promise<Result<{
+        message: string;
+    }>>;
+}
+
+/**
+ * FlowForge TypeScript Client - Main Client Factory
+ */
+
+/**
+ * FlowForge client instance with typed resource accessors.
+ */
+interface FlowForgeClient {
+    /** Events resource - send and query events */
+    events: EventsResource;
+    /** Runs resource - query and manage workflow runs */
+    runs: RunsResource;
+    /** Functions resource - manage workflow functions */
+    functions: FunctionsResource;
+    /** Tools resource - manage AI tools */
+    tools: ToolsResource;
+    /** Approvals resource - human-in-the-loop approvals */
+    approvals: ApprovalsResource;
+    /** Health resource - server health and stats */
+    health: HealthResource;
+    /** Users resource - authentication and user management */
+    users: UsersResource;
+    /** API Keys resource - manage API key authentication */
+    apiKeys: ApiKeysResource;
+}
+/**
+ * Create a FlowForge client instance.
+ *
+ * @param baseUrl - The base URL of the FlowForge server
+ * @param options - Optional client configuration
+ * @returns A FlowForge client instance
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createClient } from 'flowforge-client';
+ *
+ * const ff = createClient('http://localhost:8000');
+ *
+ * // Send an event
+ * const { data, error } = await ff.events.send('order/created', {
+ *   order_id: '123',
+ *   customer: 'Alice'
+ * });
+ * ```
+ *
+ * @example With API key
+ * ```ts
+ * const ff = createClient('http://localhost:8000', {
+ *   apiKey: process.env.FLOWFORGE_API_KEY  // ff_live_xxx
+ * });
+ * ```
+ */
+declare function createClient(baseUrl: string, options?: ClientOptions): FlowForgeClient;
+
+export { type ApiKey, type ApiKeyCreated, type ApiKeyFilters, type ApiKeyType, ApiKeysResource, type ApiKeysResponse, type Approval, type ApprovalFilters, type ApprovalStatus, ApprovalsResource, type ClientOptions, type CreateApiKeyInput, type CreateFunctionInput, type CreateToolInput, type CreateUserInput, type Event, type EventFilters, EventsResource, type FlowForgeClient, FlowForgeError, type FlowForgeFunction, type FunctionFilters, FunctionsResource, HealthResource, type HealthStatus, type OrderDirection, QueryBuilder, type QueryParams, type Result, type Run, type RunFilters, type RunStatus, type RunWithSteps, RunsResource, type SendEventInput, type SendEventResponse, type Stats, type Step, type StepStatus, type StepType, type Tool, type ToolFilters, ToolsResource, type TriggerType, type UpdateFunctionInput, type UpdateToolInput, type UpdateUserInput, type User, type UserRole, UsersResource, type UsersResponse, createClient };