@ironflow/browser 0.19.3 → 0.20.2

package/dist/client.d.ts

@@ -1,822 +0,0 @@
-/**
- * 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";
-/**
- * Ironflow browser client singleton
- */
-declare class IronflowClient {
-    private config;
-    private logger;
-    private transport;
-    private subscriptionManager;
-    private visibilityHandler;
-    /**
-     * 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;
-    /**
-     * 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;
-    }): 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