@ironflow/browser 0.20.2 → 0.22.0

package/dist/client.d.ts

@@ -0,0 +1,844 @@
+/**
+ * Ironflow Browser Client
+ *
+ * Singleton client for browser-based real-time interactions with Ironflow.
+ */
+import type { Run, ListRunsOptions, ListRunsResult, InvokeResult, EmitOptions, EmitResult, SubscriptionErrorInfo, SubscriptionCallbacks, Subscription, AckableSubscription, ConnectionState, AppendEventInput, AppendOptions, AppendResult, ReadStreamOptions, StreamEvent, StreamInfo, StreamSnapshot, EntitySubscribeOptions, GetProjectionOptions, RebuildProjectionOptions, ProjectionStatusInfo, WaitResult, WaitProgress, QuerySQLProjectionOptions, SQLProjectionQueryResult, ProjectionStateResult, ProjectionSubscriptionCallbacks, TimeTravelRunStateSnapshot, TimeTravelTimelineEvent, TimeTravelStepOutputSnapshot, APIKey, APIKeyWithSecret, CreateAPIKeyInput, Organization, CreateOrgInput, UpdateOrgInput, Role, CreateRoleInput, UpdateRoleInput, Policy, CreatePolicyInput, UpdatePolicyInput, EventSchema, RegisterSchemaInput, TestUpcastInput, UpcastResult, WebhookSource, CreateWebhookSourceInput, WebhookDelivery, ListWebhookDeliveriesOptions, AuditTrailResult, GetAuditTrailOptions, User, CreateUserInput, UpdateUserInput, Tenant } from "@ironflow/core";
+import { type EmitSyncResult } from "@ironflow/core";
+import type { IronflowConfig, IronflowConfigOptions } from "./config.js";
+import { type BrowserSubscribeOptions, type SubscriptionGroup } from "./subscription.js";
+import { BrowserKVClient } from "./kv.js";
+import { BrowserConfigClient } from "./config-client.js";
+import { type AgentsNamespace } from "./agents/index.js";
+/**
+ * Ironflow browser client singleton
+ */
+declare class IronflowClient {
+    private config;
+    private logger;
+    private transport;
+    private subscriptionManager;
+    private visibilityHandler;
+    /**
+     * `agents` namespace — browser helpers for `agent()` functions.
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.agents.invoke("my-agent", { task: "..." });
+     * console.log(result.runId, result.output);
+     *
+     * const sub = await ironflow.agents.subscribe(runId, {
+     *   onStep: (e) => console.log("step", e.stepId, e.type),
+     *   onComplete: (r) => console.log("done", r.output),
+     * });
+     * ```
+     */
+    readonly agents: AgentsNamespace;
+    /**
+     * Configure the client
+     *
+     * Must be called before any other operations.
+     */
+    configure(options?: IronflowConfigOptions): void;
+    /**
+     * Check if the client is configured
+     */
+    get isConfigured(): boolean;
+    /**
+     * Detect which transport the server supports
+     *
+     * Returns the best available transport based on server capabilities.
+     * ConnectRPC is preferred over WebSocket.
+     *
+     * @example
+     * ```typescript
+     * const transport = await ironflow.detectTransport();
+     * // Returns 'connectrpc' | 'websocket'
+     * ```
+     */
+    detectTransport(): Promise<"connectrpc" | "websocket">;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): IronflowConfig;
+    /**
+     * Connect to the Ironflow server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Ironflow server
+     */
+    disconnect(): void;
+    /**
+     * Register a callback for connection state changes
+     */
+    onConnectionChange(callback: (state: ConnectionState) => void): () => void;
+    /**
+     * Get current connection state
+     */
+    get connectionState(): ConnectionState;
+    /**
+     * Subscribe to events matching a pattern
+     *
+     * @example
+     * ```typescript
+     * // Basic subscription
+     * const sub = await ironflow.subscribe('events:order.*', {
+     *   onEvent: (event) => console.log(event),
+     * });
+     *
+     * // Multiple patterns
+     * const sub = await ironflow.subscribe(['system.run.*', 'events:order.*'], {
+     *   onEvent: (event) => { ... }
+     * });
+     *
+     * // With options
+     * const sub = await ironflow.subscribe('events:*', {
+     *   onEvent: (e) => { ... },
+     *   replay: 10,
+     *   trackState: true,
+     *   ackMode: 'manual',
+     * });
+     * ```
+     */
+    subscribe<T = unknown>(pattern: string | string[], callbacksAndOptions: SubscriptionCallbacks<T> & BrowserSubscribeOptions): Promise<Subscription | AckableSubscription>;
+    /**
+     * Create a subscription group for batch management
+     *
+     * @example
+     * ```typescript
+     * const group = ironflow.subscriptionGroup();
+     * await group.add('system.run.*', { onEvent: handleRun });
+     * await group.add('events:payment.*', { onEvent: handlePayment });
+     * // Later:
+     * group.unsubscribeAll();
+     * ```
+     */
+    subscriptionGroup(): SubscriptionGroup;
+    /**
+     * Register a global error handler
+     */
+    onError(callback: (error: SubscriptionErrorInfo) => void): () => void;
+    /**
+     * Number of currently active subscriptions. Useful for leak audits and
+     * diagnostics. Returns 0 if the client is not configured.
+     */
+    getActiveSubscriptionCount(): number;
+    /**
+     * Invoke a workflow function by ID
+     *
+     * @example
+     * ```typescript
+     * const run = await ironflow.invoke<OrderInput, OrderOutput>('process-order', {
+     *   data: { orderId: '123' }
+     * });
+     * ```
+     */
+    invoke<TInput = unknown>(functionId: string, options: {
+        data: TInput;
+        idempotencyKey?: string;
+    }): Promise<InvokeResult>;
+    /**
+     * Get run status
+     */
+    getRun(runId: string): Promise<Run>;
+    /**
+     * List runs with filtering
+     */
+    listRuns(options?: ListRunsOptions): Promise<ListRunsResult>;
+    /**
+     * Cancel a running run
+     */
+    cancelRun(runId: string, reason?: string): Promise<Run>;
+    /**
+     * Retry a failed run
+     */
+    retryRun(runId: string, fromStep?: string): Promise<Run>;
+    /**
+     * Patch a step's output (hot patching)
+     */
+    patchStep(stepId: string, output: Record<string, unknown>, reason?: string): Promise<void>;
+    /**
+     * Resume a paused or failed run
+     */
+    resumeRun(runId: string, fromStep?: string): Promise<Run>;
+    /**
+     * Pause a running workflow at the next step boundary (scoped injection).
+     */
+    pauseRun(runId: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Get the paused state of a run, including completed steps and next step hint.
+     */
+    getPausedState(runId: string): Promise<{
+        steps: Array<{
+            id: string;
+            name: string;
+            output: unknown;
+            injected: boolean;
+            completedAt: string;
+        }>;
+        nextStepHint: string;
+        pauseReason: string;
+    }>;
+    /**
+     * Inject new output for a step in a paused run (scoped injection).
+     */
+    injectStepOutput(runId: string, stepId: string, newOutput: unknown, reason?: string): Promise<{
+        stepId: string;
+        previousOutput: unknown;
+    }>;
+    /**
+     * Get the reconstructed state of a run at a specific timestamp.
+     */
+    getRunStateAt(runId: string, timestamp: Date): Promise<TimeTravelRunStateSnapshot>;
+    /**
+     * Get the timeline of audit events for a run.
+     */
+    getRunTimeline(runId: string): Promise<TimeTravelTimelineEvent[]>;
+    /**
+     * Get the output of a specific step at a specific timestamp.
+     */
+    getStepOutputAt(runId: string, stepId: string, timestamp: Date): Promise<TimeTravelStepOutputSnapshot>;
+    /**
+     * List registered functions
+     */
+    listFunctions(): Promise<unknown[]>;
+    /**
+     * List connected workers
+     */
+    listWorkers(): Promise<unknown[]>;
+    /**
+     * Health check
+     */
+    health(): Promise<{
+        status: string;
+        timestamp: string;
+        version: string;
+    }>;
+    /**
+     * Get server capabilities
+     */
+    getCapabilities(): Promise<{
+        transports: string[];
+        features: string[];
+        version: string;
+    }>;
+    /**
+     * Emit an event
+     *
+     * @example
+     * ```typescript
+     * await ironflow.emit('order.approved', {
+     *   orderId: '123',
+     *   approvedBy: 'user@example.com'
+     * });
+     * ```
+     */
+    emit(eventName: string, data: unknown, options?: EmitOptions): Promise<EmitResult>;
+    /**
+     * Emit an event synchronously — waits for the triggered run to complete and returns the result.
+     *
+     * Calls the TriggerSync endpoint, which blocks until the run finishes or the timeout elapses.
+     * Throws RunFailedError if the run fails, RunCancelledError if it is cancelled.
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.emitSync("order.placed", { orderId: "123" });
+     * console.log("Output:", result.output);
+     * ```
+     */
+    emitSync(eventName: string, data: unknown, options?: {
+        timeout?: number;
+    }): Promise<EmitSyncResult>;
+    /**
+     * Join a consumer group for load-balanced event processing
+     */
+    joinConsumerGroup<T = unknown>(groupName: string, pattern: string, callbacksAndOptions: SubscriptionCallbacks<T> & BrowserSubscribeOptions): Promise<AckableSubscription>;
+    /**
+     * Entity stream operations
+     *
+     * @example
+     * ```typescript
+     * // Append an event to a stream
+     * const result = await ironflow.streams.append("order-123", {
+     *   name: "order.created",
+     *   data: { total: 100 },
+     *   entityType: "order",
+     * });
+     *
+     * // Read events from a stream
+     * const { events } = await ironflow.streams.read("order-123", { limit: 10 });
+     *
+     * // Get stream info
+     * const info = await ironflow.streams.getInfo("order-123");
+     * ```
+     */
+    streams: {
+        /**
+         * Append an event to an entity stream
+         */
+        append: (entityId: string, input: AppendEventInput, options?: AppendOptions) => Promise<AppendResult>;
+        /**
+         * Read events from an entity stream
+         */
+        read: (entityId: string, options?: ReadStreamOptions) => Promise<{
+            events: StreamEvent[];
+            totalCount: number;
+        }>;
+        /**
+         * Get information about an entity stream.
+         *
+         * Returns `null` if no events have been written to this stream yet — safe to
+         * pass `expectedVersion: 0` to `append()` in that case to create the first event.
+         *
+         * @example
+         * ```typescript
+         * const info = await ironflow.streams.getInfo("order-123");
+         * await ironflow.streams.append("order-123", event, {
+         *   expectedVersion: info ? info.version : 0,
+         * });
+         * ```
+         */
+        getInfo: (entityId: string) => Promise<StreamInfo | null>;
+        /**
+         * Create a snapshot of the materialized state at a specific stream version.
+         */
+        createSnapshot: (entityId: string, input: {
+            entityType: string;
+            entityVersion: number;
+            state: Record<string, unknown>;
+        }) => Promise<{
+            snapshotId: string;
+        }>;
+        /**
+         * Get the latest snapshot at or before a given version.
+         */
+        getSnapshot: (entityId: string, options?: {
+            beforeVersion?: number;
+        }) => Promise<StreamSnapshot>;
+        /**
+         * Subscribe to real-time events for an entity stream
+         *
+         * @example
+         * ```typescript
+         * const sub = await ironflow.streams.subscribe("order-123", {
+         *   entityType: "order",
+         *   onEvent: (event) => console.log(event),
+         *   replay: 100,
+         * });
+         *
+         * // Cleanup
+         * sub.unsubscribe();
+         * ```
+         */
+        subscribe: (entityId: string, options: EntitySubscribeOptions) => Promise<Subscription>;
+    };
+    /**
+     * Get the current state of a projection
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.getProjection<OrderStats>('order-stats');
+     * console.log(result.state); // { totalOrders: 42, ... }
+     *
+     * // With partition
+     * const result = await ironflow.getProjection('order-stats', { partition: 'customer-123' });
+     * ```
+     */
+    getProjection<TState = unknown>(name: string, options?: GetProjectionOptions): Promise<ProjectionStateResult<TState>>;
+    /**
+     * Query a SQL-backed projection table with optional filtering, ordering, and pagination.
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.querySQLProjection('board', {
+     *   where: "status = 'OPEN'",
+     *   orderBy: "title ASC",
+     *   limit: 50,
+     * });
+     * ```
+     */
+    querySQLProjection(name: string, options?: QuerySQLProjectionOptions): Promise<SQLProjectionQueryResult>;
+    /**
+     * Get the status of a projection
+     *
+     * @example
+     * ```typescript
+     * const status = await ironflow.getProjectionStatus('order-stats');
+     * console.log(status.status); // 'active' | 'rebuilding' | 'paused' | 'error'
+     * ```
+     */
+    getProjectionStatus(name: string): Promise<ProjectionStatusInfo>;
+    /**
+     * Trigger a rebuild of a projection
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.rebuildProjection('order-stats');
+     * ```
+     */
+    rebuildProjection(name: string, options?: RebuildProjectionOptions): Promise<{
+        status: string;
+    }>;
+    /**
+     * Wait until the named projection has processed events up to `minSeq`,
+     * or the timeout elapses. Read-your-writes primitive for CQRS UIs:
+     * pair with `sequence` from an `appendEntityEvent` response.
+     *
+     * Issue #473.
+     */
+    waitForProjectionCatchup(name: string, opts: {
+        minSeq: number | bigint;
+        timeoutMs?: number;
+        partition?: string;
+    }): Promise<WaitResult>;
+    /**
+     * Streaming wait for a projection to catch up to `minSeq` (issue #476).
+     *
+     * Returns an `AsyncIterable<WaitProgress>` that yields a frame each time
+     * the projection cursor advances, plus one terminal frame (`terminal:
+     * true`) on catch-up, timeout, or error, after which iteration ends.
+     * Heartbeats are filtered inside the SDK — callers never see them.
+     *
+     * Unlike the unary `waitForProjectionCatchup`, this path uses a
+     * server-streaming ConnectRPC connection. The server caps the wait at
+     * 300s regardless of `timeoutMs`. Pass `opts.signal` to cancel early
+     * (e.g., on React unmount); breaking out of `for await` also aborts
+     * the stream.
+     *
+     * Example:
+     * ```ts
+     * for await (const p of ironflow.waitForProjectionCatchupStream("order-view", { minSeq: 42 })) {
+     *   if (p.terminal) {
+     *     if (p.caughtUp) return;
+     *     throw new Error(`wait failed: timedOut=${p.timedOut} error=${p.error}`);
+     *   }
+     *   console.log(`progress: ${p.currentSeq}/${p.targetSeq} behind=${p.behindByEvents}`);
+     * }
+     * ```
+     */
+    waitForProjectionCatchupStream(name: string, opts: {
+        minSeq: number | bigint;
+        timeoutMs?: number;
+        partition?: string;
+        signal?: AbortSignal;
+    }): AsyncIterable<WaitProgress>;
+    /**
+     * Wait for a specific event to be processed by the given projection.
+     * The server resolves `eventId` to its NATS sequence internally.
+     *
+     * Issue #473.
+     */
+    waitForEvent(eventId: string, projection: string, opts?: {
+        timeoutMs?: number;
+        partition?: string;
+    }): Promise<WaitResult>;
+    /**
+     * List all registered projections
+     *
+     * @example
+     * ```typescript
+     * const projections = await ironflow.listProjections();
+     * projections.forEach(p => console.log(p.name, p.status));
+     * ```
+     */
+    listProjections(): Promise<ProjectionStatusInfo[]>;
+    /**
+     * Subscribe to real-time updates for a projection
+     *
+     * @example
+     * ```typescript
+     * const sub = await ironflow.subscribeToProjection<OrderStats>('order-stats', {
+     *   onUpdate: (state, event) => console.log('Updated:', state),
+     *   onError: (error) => console.error(error),
+     * });
+     *
+     * // With partition
+     * const sub = await ironflow.subscribeToProjection('order-stats', {
+     *   onUpdate: (state, event) => console.log('Updated:', state),
+     * }, { partition: 'customer-123' });
+     *
+     * // Cleanup
+     * sub.unsubscribe();
+     * ```
+     */
+    subscribeToProjection<TState = unknown>(name: string, callbacks: ProjectionSubscriptionCallbacks<TState>, options?: {
+        partition?: string;
+        replay?: number;
+    }): Promise<Subscription>;
+    /**
+     * KV store operations
+     *
+     * @example
+     * ```typescript
+     * const kv = ironflow.kv();
+     * const bucket = await kv.createBucket({ name: "sessions", ttlSeconds: 3600 });
+     * const handle = kv.bucket("sessions");
+     * const { revision } = await handle.put("user.123", { token: "abc" });
+     * const entry = await handle.get("user.123");
+     *
+     * // Watch for changes
+     * const watcher = handle.watch({
+     *   onUpdate: (event) => console.log(event),
+     * }, { key: "user.*" });
+     * ```
+     */
+    kv(): BrowserKVClient;
+    /**
+     * Config management operations
+     *
+     * @example
+     * ```typescript
+     * const cfg = ironflow.configManager();
+     * await cfg.set("app", { featureX: true, maxRetries: 3 });
+     * const { data, revision } = await cfg.get("app");
+     * await cfg.patch("app", { maxRetries: 5 });
+     * const configs = await cfg.list();
+     * await cfg.delete("app");
+     *
+     * // Watch for changes
+     * const sub = await cfg.watch("app", {
+     *   onEvent: (config) => console.log(config),
+     * });
+     * sub.unsubscribe();
+     * ```
+     */
+    configManager(): BrowserConfigClient;
+    /**
+     * API key management operations
+     *
+     * @example
+     * ```typescript
+     * // Create an API key
+     * const key = await ironflow.apiKeys.create({ name: "my-key" });
+     * console.log(key.key); // Only shown once
+     *
+     * // List API keys
+     * const keys = await ironflow.apiKeys.list();
+     *
+     * // Delete an API key
+     * await ironflow.apiKeys.delete(key.id);
+     * ```
+     */
+    readonly apiKeys: {
+        /**
+         * Create a new API key
+         */
+        create: (input: CreateAPIKeyInput) => Promise<APIKeyWithSecret>;
+        /**
+         * List all API keys
+         */
+        list: () => Promise<APIKey[]>;
+        /**
+         * Get an API key by ID
+         */
+        get: (id: string) => Promise<APIKey>;
+        /**
+         * Delete an API key
+         */
+        delete: (id: string) => Promise<void>;
+        /**
+         * Rotate an API key, returning a new secret
+         */
+        rotate: (id: string) => Promise<APIKeyWithSecret>;
+    };
+    /**
+     * Organization management operations (enterprise-only)
+     *
+     * @example
+     * ```typescript
+     * // Create an organization
+     * const org = await ironflow.orgs.create({ name: "Acme Corp" });
+     *
+     * // List organizations
+     * const orgs = await ironflow.orgs.list();
+     *
+     * // Update an organization
+     * await ironflow.orgs.update(org.id, { name: "Acme Inc" });
+     * ```
+     */
+    readonly orgs: {
+        /**
+         * Create a new organization
+         */
+        create: (input: CreateOrgInput) => Promise<Organization>;
+        /**
+         * List all organizations
+         */
+        list: () => Promise<Organization[]>;
+        /**
+         * Get an organization by ID
+         */
+        get: (id: string) => Promise<Organization>;
+        /**
+         * Update an organization
+         */
+        update: (id: string, input: UpdateOrgInput) => Promise<Organization>;
+        /**
+         * Delete an organization
+         */
+        delete: (id: string) => Promise<void>;
+    };
+    /**
+     * Role management operations (enterprise-only)
+     *
+     * @example
+     * ```typescript
+     * // Create a role
+     * const role = await ironflow.roles.create({ name: "editor", org_id: "org-1" });
+     *
+     * // Assign a policy to the role
+     * await ironflow.roles.assignPolicy(role.id, policyId);
+     *
+     * // List roles
+     * const roles = await ironflow.roles.list();
+     * ```
+     */
+    readonly roles: {
+        /**
+         * Create a new role
+         */
+        create: (input: CreateRoleInput) => Promise<Role>;
+        /**
+         * List all roles
+         */
+        list: (orgId?: string) => Promise<Role[]>;
+        /**
+         * Get a role by ID
+         */
+        get: (id: string) => Promise<Role>;
+        /**
+         * Update a role
+         */
+        update: (id: string, input: UpdateRoleInput) => Promise<Role>;
+        /**
+         * Delete a role
+         */
+        delete: (id: string) => Promise<void>;
+        /**
+         * Assign a policy to a role
+         */
+        assignPolicy: (roleId: string, policyId: string) => Promise<void>;
+        /**
+         * Remove a policy from a role
+         */
+        removePolicy: (roleId: string, policyId: string) => Promise<void>;
+    };
+    /**
+     * Policy management operations (enterprise-only)
+     *
+     * @example
+     * ```typescript
+     * // Create a policy
+     * const policy = await ironflow.policies.create({
+     *   name: "allow-read",
+     *   effect: "allow",
+     *   actions: "read",
+     *   resources: "*",
+     *   org_id: "org-1",
+     * });
+     *
+     * // List policies
+     * const policies = await ironflow.policies.list();
+     * ```
+     */
+    readonly policies: {
+        /**
+         * Create a new policy
+         */
+        create: (input: CreatePolicyInput) => Promise<Policy>;
+        /**
+         * List all policies
+         */
+        list: (orgId?: string) => Promise<Policy[]>;
+        /**
+         * Get a policy by ID
+         */
+        get: (id: string) => Promise<Policy>;
+        /**
+         * Update a policy
+         */
+        update: (id: string, input: UpdatePolicyInput) => Promise<Policy>;
+        /**
+         * Delete a policy
+         */
+        delete: (id: string) => Promise<void>;
+    };
+    /**
+     * Event schema registry operations
+     *
+     * @example
+     * ```typescript
+     * // Register a schema
+     * const schema = await ironflow.schemas.register({
+     *   name: "order.placed",
+     *   version: 1,
+     *   schema: { type: "object", properties: { orderId: { type: "string" } } },
+     * });
+     *
+     * // List all schemas
+     * const schemas = await ironflow.schemas.list();
+     *
+     * // Get latest version of a schema
+     * const latest = await ironflow.schemas.get("order.placed");
+     *
+     * // Test an upcast transformation
+     * const result = await ironflow.schemas.testUpcast({
+     *   eventName: "order.placed",
+     *   fromVersion: 1,
+     *   toVersion: 2,
+     *   data: { orderId: "123" },
+     * });
+     * ```
+     */
+    readonly schemas: {
+        /** Register a new event schema (or a new version of an existing schema) */
+        register: (input: RegisterSchemaInput) => Promise<EventSchema>;
+        /** List all registered event schemas */
+        list: () => Promise<EventSchema[]>;
+        /** Get the latest version of an event schema by name */
+        get: (name: string) => Promise<EventSchema>;
+        /** Get a specific version of an event schema */
+        getVersion: (name: string, version: number) => Promise<EventSchema>;
+        /** Delete a specific version of an event schema */
+        delete: (name: string, version: number) => Promise<void>;
+        /** Test an upcast transformation between two schema versions */
+        testUpcast: (input: TestUpcastInput) => Promise<UpcastResult>;
+    };
+    /**
+     * Get the audit trail for a run.
+     *
+     * @param runId The run ID to retrieve the audit trail for
+     * @param options Optional filtering options
+     *
+     * @example
+     * ```typescript
+     * const result = await ironflow.getAuditTrail("run-abc123");
+     * for (const event of result.events) {
+     *   console.log(event.eventType, event.createdAt);
+     * }
+     * ```
+     */
+    getAuditTrail(runId: string, options?: GetAuditTrailOptions): Promise<AuditTrailResult>;
+    /**
+     * Webhook management operations
+     *
+     * @example
+     * ```typescript
+     * // List all webhook sources
+     * const sources = await ironflow.webhooks.listSources();
+     *
+     * // Delete a webhook source
+     * await ironflow.webhooks.deleteSource("my-webhook");
+     *
+     * // List deliveries
+     * const { deliveries } = await ironflow.webhooks.listDeliveries({ sourceId: "my-webhook" });
+     * ```
+     */
+    readonly webhooks: {
+        /** Create a new webhook source */
+        create: (input: CreateWebhookSourceInput) => Promise<WebhookSource>;
+        /** List all registered webhook sources */
+        listSources: () => Promise<WebhookSource[]>;
+        /** Delete a webhook source by ID */
+        deleteSource: (id: string) => Promise<void>;
+        /** List webhook deliveries with optional filtering */
+        listDeliveries: (opts?: ListWebhookDeliveriesOptions) => Promise<{
+            deliveries: WebhookDelivery[];
+            totalCount: number;
+        }>;
+    };
+    /**
+     * User management operations
+     *
+     * @example
+     * ```typescript
+     * // List all users
+     * const users = await ironflow.users.list();
+     *
+     * // Create a user
+     * const user = await ironflow.users.create({
+     *   email: "alice@example.com",
+     *   password: "secret",
+     *   roles: ["admin"],
+     * });
+     *
+     * // Update a user
+     * await ironflow.users.update(user.id, { name: "Alice" });
+     * ```
+     */
+    readonly users: {
+        /** Create a new user (admin only) */
+        create: (input: CreateUserInput) => Promise<User>;
+        /** List all users in the current organization (admin only) */
+        list: () => Promise<User[]>;
+        /** Get a user by ID */
+        get: (id: string) => Promise<User>;
+        /** Update a user's profile (admin only) */
+        update: (id: string, input: UpdateUserInput) => Promise<User>;
+        /** Delete a user (admin only) */
+        delete: (id: string) => Promise<void>;
+    };
+    /**
+     * Tenant management operations (enterprise-only)
+     *
+     * @example
+     * ```typescript
+     * // List all tenants
+     * const tenants = await ironflow.tenants.list();
+     * ```
+     */
+    readonly tenants: {
+        /** List all tenants (enterprise-only) */
+        list: () => Promise<Tenant[]>;
+    };
+    /**
+     * Pattern helpers for building subscription patterns
+     */
+    static patterns: {
+        readonly allRuns: () => string;
+        readonly run: (runId: string) => string;
+        readonly runLifecycle: (runId: string) => string;
+        readonly runSteps: (runId: string) => string;
+        readonly allFunctions: () => string;
+        readonly function: (functionId: string) => string;
+        readonly userEvent: (eventName: string) => string;
+        readonly allUserEvents: () => string;
+        readonly allSecrets: () => string;
+        readonly secret: (name: string) => string;
+        readonly secretAction: (action: string) => string;
+        readonly topic: (topicPattern: string) => string;
+        readonly allTopics: () => string;
+    };
+    private ensureConfigured;
+    private cleanup;
+    /**
+     * Reset client state for testing. Not intended for production use.
+     * @internal
+     */
+    _resetForTesting(): void;
+    private setupVisibilityHandling;
+    private request;
+    private streamRequest;
+    /**
+     * REST request helper for auth management endpoints.
+     *
+     * Supports GET, POST, PATCH, DELETE methods with typed error mapping:
+     * - 401 → UnauthenticatedError
+     * - 402 → EnterpriseRequiredError
+     * - 403 → UnauthorizedError
+     */
+    private restRequest;
+    private mapRunResponse;
+}
+/**
+ * Singleton instance
+ */
+export declare const ironflow: IronflowClient;
+/**
+ * Export the class for advanced usage
+ */
+export { IronflowClient };
+//# sourceMappingURL=client.d.ts.map