@invect/core 0.0.1

package/dist/invect-core.d.cts

@@ -0,0 +1,846 @@
+import { PaginatedResponse, QueryOptions } from "./types/schemas/pagination-sort-filter.cjs";
+import { CreateFlowRequest } from "./types/schemas/flow/create-flow.schema.cjs";
+import { InvectConfig, InvectDatabaseConfig } from "./types/schemas-fresh/invect-config.cjs";
+import { CreateFlowVersionRequest } from "./services/flow-versions/schemas-fresh.cjs";
+import { AgentPromptResult, AgentToolDefinition } from "./types/agent-tool.types.cjs";
+import { SQLQueryResult, SubmitPromptRequest, SubmitSQLQueryRequest } from "./services/node-data.service.cjs";
+import { SubmitAgentPromptRequest } from "./types-fresh.cjs";
+import { NodeDefinition } from "./types/node-definition.types.cjs";
+import { OAuth2ProviderDefinition } from "./services/credentials/oauth2-providers.cjs";
+import { OAuth2PendingState, OAuth2StartResult } from "./services/credentials/oauth2.service.cjs";
+import { CreateCredentialInput, Credential, CredentialFilters, CredentialsService, UpdateCredentialInput } from "./services/credentials/credentials.service.cjs";
+import { ActionDefinition, LoadOptionsResult, ProviderDef } from "./actions/types.cjs";
+import { AuthEvent, AuthorizationContext, AuthorizationResult, InvectIdentity, InvectPermission } from "./types/auth.types.cjs";
+import { InvectPlugin, InvectPluginEndpoint, PluginHookRunner } from "./types/plugin.types.cjs";
+import { FlowRun } from "./services/flow-runs/flow-runs.model.cjs";
+import { Flow, UpdateFlowInput } from "./services/flows/flows.model.cjs";
+import { NodeExecution } from "./services/node-executions/node-executions.model.cjs";
+import { CreateTriggerInput, FlowTriggerRegistration, UpdateTriggerInput } from "./services/triggers/trigger.types.cjs";
+import { ChatMessageRecord } from "./services/chat/chat-messages.model.cjs";
+import { BatchProvider, Model } from "./services/ai/ai-types.cjs";
+import { FlowVersion } from "./database/schema-sqlite.cjs";
+import { DatabaseConnection } from "./database/connection.cjs";
+import { ChatStreamEvent } from "./services/chat/chat-types.cjs";
+import { ActionRegistry } from "./actions/action-registry.cjs";
+import { ExecutionStreamEvent } from "./services/execution-event-bus.cjs";
+import { ExecuteFlowOptions, FlowInputs, FlowRunResult } from "./services/flow-runs/flow-runs.service.cjs";
+import { NodeConfigUpdateEvent, NodeConfigUpdateResponse } from "./types/node-config-update.types.cjs";
+import { NodeExecutorRegistry } from "./nodes/executor-registry.cjs";
+import { FlowAccessPermission, FlowAccessRecord } from "./services/auth/flow-access.service.cjs";
+import { ReactFlowData } from "./services/react-flow-renderer.service.cjs";
+import { ServiceFactory } from "./services/service-factory.cjs";
+import { FlowValidationResult } from "./types/validation.cjs";
+import { LogLevel, LoggerManager, ScopedLogger } from "./utils/logger.cjs";
+import { AuthorizationService } from "./services/auth/authorization.service.cjs";
+//#region src/invect-core.d.ts
+/**
+ * Custom node configuration interface
+ */
+interface CustomNodeConfig {
+  nodeType: string;
+  executor: string;
+  config?: Record<string, unknown>;
+}
+/**
+ * Invect Core initialization status
+ */
+interface CoreInitializationStatus {
+  isInitialized: boolean;
+  servicesReady: boolean;
+  databaseReady: boolean;
+  errors?: string[];
+}
+/**
+ * Dashboard statistics returned by getDashboardStats()
+ */
+interface DashboardStats {
+  /** Total number of flows */
+  totalFlows: number;
+  /** Total number of flow runs (all time) */
+  totalRuns: number;
+  /** Number of runs in the last 24 hours */
+  runsLast24h: number;
+  /** Currently active runs (RUNNING + PENDING + PAUSED_FOR_BATCH) */
+  activeRuns: number;
+  /** Success rate as percentage (0-100) */
+  successRate: number;
+  /** Number of failed runs in the last 24 hours */
+  failedRunsLast24h: number;
+  /** Run counts keyed by FlowRunStatus */
+  runsByStatus: Record<string, number>;
+  /** Most recent 10 flow runs */
+  recentRuns: FlowRun[];
+}
+/**
+ * Main Invect Core class
+ *
+ * Provides a high-level API for flow operations with comprehensive lifecycle management.
+ * This class orchestrates all flow-related operations including:
+ * - Flow and flow version management
+ * - Flow execution and monitoring
+ * - Node execution tracking
+ * - AI batch operations
+ * - Testing and development utilities
+ *
+ * @example
+ * ```typescript
+ * const invect = new Invect(config);
+ * await invect.initialize();
+ *
+ * const flow = await invect.createFlow({ name: "My Flow", description: "..." });
+ * const result = await invect.startFlowRun(flow.id, inputs);
+ *
+ * await invect.shutdown();
+ * ```
+ */
+declare class Invect {
+  private readonly config;
+  protected serviceFactory: ServiceFactory | null;
+  protected nodeRegistry: NodeExecutorRegistry | null;
+  protected actionRegistry: ActionRegistry | null;
+  private jsExpressionService;
+  private templateService;
+  private pluginManager;
+  private initialized;
+  private loggerManager;
+  private authService;
+  /**
+   * Creates a new Invect instance
+   *
+   * @param config - Invect configuration object
+   */
+  constructor(config: InvectConfig);
+  /**
+   * Authorize an action for an identity.
+   *
+   * This is the main entry point for authorization checks. Framework adapters
+   * (Express, NestJS, Next.js) should call this method to check permissions.
+   *
+   * @param context - Authorization context with identity, action, and optional resource
+   * @returns Authorization result with allowed flag and optional reason
+   *
+   * @example
+   * ```typescript
+   * const result = await invect.authorize({
+   *   identity: { id: 'user_123', role: 'editor' },
+   *   action: 'flow:create',
+   * });
+   *
+   * if (!result.allowed) {
+   *   throw new ForbiddenError(result.reason);
+   * }
+   * ```
+   */
+  authorize(context: AuthorizationContext): Promise<AuthorizationResult>;
+  /**
+   * Check if a specific identity has a permission.
+   * Convenience method that wraps authorize().
+   */
+  hasPermission(identity: InvectIdentity | null, permission: InvectPermission): boolean;
+  /**
+   * Get all permissions for an identity.
+   */
+  getPermissions(identity: InvectIdentity | null): InvectPermission[];
+  /**
+   * Check if a plugin is registered by ID.
+   */
+  hasPlugin(pluginId: string): boolean;
+  /**
+   * Get a registered plugin by ID.
+   */
+  getPlugin(pluginId: string): InvectPlugin | null;
+  /**
+   * Get all registered plugins.
+   */
+  getPlugins(): readonly InvectPlugin[];
+  /**
+   * Get all plugin-defined API endpoints.
+   * Framework adapters use this to mount plugin routes.
+   */
+  getPluginEndpoints(): InvectPluginEndpoint[];
+  /**
+   * Get the plugin hook runner for framework adapters.
+   * Used to run onRequest/onResponse/onAuthorize hooks.
+   */
+  getPluginHookRunner(): PluginHookRunner;
+  /**
+   * Get the initialized host database connection.
+   * Framework adapters use this to expose a narrow database API to plugins.
+   */
+  getDatabaseConnection(): DatabaseConnection;
+  /**
+   * Check if authentication is enabled.
+   */
+  isAuthEnabled(): boolean;
+  /**
+   * Check if a route is public (no auth required).
+   */
+  isPublicRoute(path: string): boolean;
+  /**
+   * Get the authorization service for advanced use cases.
+   * The service extends EventEmitter and emits auth events.
+   */
+  getAuthService(): AuthorizationService;
+  /**
+   * Get available roles and their permissions.
+   * Useful for admin UIs to show role options.
+   */
+  getAvailableRoles(): {
+    role: string;
+    permissions: InvectPermission[];
+  }[];
+  /**
+   * Subscribe to auth events for audit logging.
+   *
+   * @example
+   * ```typescript
+   * invect.onAuthEvent('auth:forbidden', (event) => {
+   *   auditLogger.warn('Access denied', event);
+   * });
+   * ```
+   */
+  onAuthEvent<T extends AuthEvent['type']>(event: T, listener: (event: Extract<AuthEvent, {
+    type: T;
+  }>) => void): void;
+  /**
+   * Check if flow access table is enabled.
+   */
+  isFlowAccessTableEnabled(): boolean;
+  /**
+   * Grant access to a flow for a user or team.
+   * Requires useFlowAccessTable: true in config.
+   *
+   * @example
+   * ```typescript
+   * // Grant editor access to a user
+   * await invect.grantFlowAccess({
+   *   flowId: 'flow_123',
+   *   userId: 'user_456',
+   *   permission: 'editor',
+   *   grantedBy: currentUser.id,
+   * });
+   *
+   * // Grant viewer access to a team
+   * await invect.grantFlowAccess({
+   *   flowId: 'flow_123',
+   *   teamId: 'team_abc',
+   *   permission: 'viewer',
+   * });
+   * ```
+   */
+  grantFlowAccess(input: {
+    flowId: string;
+    userId?: string;
+    teamId?: string;
+    permission: 'owner' | 'editor' | 'operator' | 'viewer';
+    grantedBy?: string;
+    expiresAt?: Date | string;
+  }): Promise<FlowAccessRecord>;
+  /**
+   * Revoke a specific flow access record.
+   * Requires useFlowAccessTable: true in config.
+   */
+  revokeFlowAccess(accessId: string): Promise<void>;
+  /**
+   * Revoke all access to a flow for a specific user or team.
+   * Requires useFlowAccessTable: true in config.
+   */
+  revokeFlowAccessForUserOrTeam(flowId: string, userId?: string, teamId?: string): Promise<void>;
+  /**
+   * List all access records for a flow.
+   * Requires useFlowAccessTable: true in config.
+   */
+  listFlowAccess(flowId: string): Promise<FlowAccessRecord[]>;
+  /**
+   * Get all flows a user has access to (directly or via teams).
+   * Requires useFlowAccessTable: true in config.
+   */
+  getAccessibleFlowIds(userId: string, teamIds?: string[]): Promise<string[]>;
+  /**
+   * Check if a user has access to a flow with at least the required permission.
+   * Requires useFlowAccessTable: true in config.
+   */
+  hasFlowAccess(flowId: string, userId: string, teamIds?: string[], requiredPermission?: 'owner' | 'editor' | 'operator' | 'viewer'): Promise<boolean>;
+  /**
+   * Get the highest permission level a user has for a flow.
+   * Requires useFlowAccessTable: true in config.
+   */
+  getFlowPermission(flowId: string, userId: string, teamIds?: string[]): Promise<FlowAccessPermission | null>;
+  /**
+   * Get a scoped logger for a specific feature area.
+   *
+   * Scoped loggers have independent log levels that can be configured
+   * per scope via the logging.scopes configuration.
+   *
+   * @param scope - The scope/feature area (use LogScope constants)
+   * @param context - Optional additional context (e.g., class name)
+   * @returns A ScopedLogger instance
+   *
+   * @example
+   * ```typescript
+   * const logger = invect.getLogger('execution', 'MyService');
+   * logger.debug('Starting execution'); // Only logs if execution scope is 'debug'
+   * ```
+   */
+  getLogger(scope: string, context?: string): ScopedLogger;
+  /**
+   * Get the logger manager for advanced logging configuration
+   */
+  getLoggerManager(): LoggerManager;
+  /**
+   * Update the log level for a specific scope at runtime
+   *
+   * @example
+   * ```typescript
+   * // Enable debug logging for execution during troubleshooting
+   * invect.setLogLevel('execution', 'debug');
+   * ```
+   */
+  setLogLevel(scope: string, level: LogLevel): void;
+  /**
+   * Initialize Invect Core
+   */
+  initialize(): Promise<void>;
+  /**
+   * Check if we're in a build-time environment where database connections should be avoided
+   */
+  private isBuildTime;
+  /**
+   * Gracefully shutdown Invect Core.
+   * Marks any in-progress flow runs as FAILED before closing services.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Check if core is initialized
+   */
+  isInitialized(): boolean;
+  /**
+   * Run health check on all services
+   */
+  healthCheck(): Promise<{
+    [serviceName: string]: boolean;
+  }>;
+  /**
+   * Create a new flow
+   */
+  createFlow(flowData: CreateFlowRequest): Promise<Flow>;
+  /**
+   * Get all flows with optional filtering, sorting, and pagination
+   */
+  listFlows(options?: QueryOptions<Flow>): Promise<PaginatedResponse<Flow>>;
+  /**
+   * Get flow by ID
+   */
+  getFlow(flowId: string): Promise<Flow>;
+  /**
+   * Update an existing flow
+   */
+  updateFlow(flowId: string, updateData: UpdateFlowInput): Promise<Flow>;
+  /**
+   * Delete a flow
+   */
+  deleteFlow(flowId: string): Promise<void>;
+  /**
+   * Validate flow definition
+   */
+  validateFlowDefinition(flowId: string, flowDefinition: unknown): Promise<FlowValidationResult>;
+  /**
+   * Create flow version and sync trigger registrations (D3: sync on publish)
+   */
+  createFlowVersion(flowId: string, versionData: CreateFlowVersionRequest): Promise<FlowVersion>;
+  /**
+   * Get flow versions with optional filtering, sorting, and pagination
+   */
+  listFlowVersions(flowId: string, options?: QueryOptions<FlowVersion>): Promise<PaginatedResponse<FlowVersion>>;
+  /**
+   * Get specific flow version by version number or 'latest'
+   */
+  getFlowVersion(flowId: string, version: string | number | 'latest'): Promise<FlowVersion | null>;
+  /**
+   * Execute a flow (synchronous - waits for completion)
+   */
+  startFlowRun(flowId: string, inputs?: FlowInputs, options?: ExecuteFlowOptions): Promise<FlowRunResult>;
+  /**
+   * Start a flow execution asynchronously - returns immediately with flow run ID.
+   * The flow executes in the background. Use this for UI-initiated runs where
+   * you want to redirect the user immediately without waiting for completion.
+   */
+  startFlowRunAsync(flowId: string, inputs?: FlowInputs, options?: ExecuteFlowOptions): Promise<FlowRunResult>;
+  /**
+   * Execute a flow up to a specific target node.
+   * Only executes the upstream nodes required to produce output for the target node.
+   * This is useful for testing a specific node with its real upstream dependencies.
+   *
+   * @param flowId - The flow to execute
+   * @param targetNodeId - The node to execute up to (this node will also be executed)
+   * @param inputs - Flow-level inputs
+   * @param options - Execution options (version, batch processing, etc.)
+   * @returns The flow run result with the target node's output
+   */
+  executeFlowToNode(flowId: string, targetNodeId: string, inputs?: FlowInputs, options?: ExecuteFlowOptions): Promise<FlowRunResult>;
+  /**
+   * Resume execution
+   */
+  resumeExecution(executionId: string): Promise<{
+    message: string;
+    timestamp: string;
+  }>;
+  /**
+   * Get all Flow Runs
+   */
+  listFlowRuns(options?: QueryOptions<FlowRun>): Promise<PaginatedResponse<FlowRun>>;
+  /**
+   * Get flow executions for a specific flow
+   */
+  listFlowRunsByFlowId(flowId: string): Promise<PaginatedResponse<FlowRun>>;
+  /**
+   * Get a specific flow run by ID
+   */
+  getFlowRunById(flowRunId: string): Promise<FlowRun>;
+  /**
+   * Cancel a flow run
+   */
+  cancelFlowRun(flowRunId: string): Promise<{
+    message: string;
+    timestamp: string;
+  }>;
+  /**
+   * Pause a flow run
+   */
+  pauseFlowRun(flowRunId: string, reason?: string): Promise<{
+    message: string;
+    timestamp: string;
+  }>;
+  /**
+   * Get dashboard statistics: flow counts, run counts by status, recent activity.
+   */
+  getDashboardStats(): Promise<DashboardStats>;
+  /**
+   * Create a credential
+   */
+  createCredential(input: CreateCredentialInput): Promise<Credential>;
+  /**
+   * List credentials with optional filters
+   */
+  listCredentials(filters?: CredentialFilters): Promise<Array<Omit<Credential, 'config'>>>;
+  /**
+   * Retrieve a credential by id
+   */
+  getCredential(id: string): Promise<Credential>;
+  /**
+   * Update credential
+   */
+  updateCredential(id: string, input: UpdateCredentialInput): Promise<Credential>;
+  /**
+   * Delete credential
+   */
+  deleteCredential(id: string): Promise<void>;
+  /**
+   * Test credential validity
+   */
+  testCredential(id: string): Promise<{
+    success: boolean;
+    error?: string;
+  }>;
+  /**
+   * Update credential last used timestamp
+   */
+  updateCredentialLastUsed(id: string): Promise<void>;
+  /**
+   * Get expiring credentials helper
+   */
+  getExpiringCredentials(daysUntilExpiry?: number): Promise<Credential[]>;
+  /**
+   * Get node executions by flow run ID
+   */
+  getNodeExecutionsByRunId(flowRunId: string): Promise<NodeExecution[]>;
+  /**
+   * Get all node executions with optional filtering, sorting, and pagination
+   */
+  listNodeExecutions(options?: QueryOptions<NodeExecution>): Promise<PaginatedResponse<NodeExecution>>;
+  /**
+   * Create an async iterable that yields execution events for a flow run.
+   *
+   * The first event is always a "snapshot" with the current FlowRun and all
+   * NodeExecutions.  Subsequent events are incremental updates.  The stream
+   * ends automatically when the flow run reaches a terminal status.
+   *
+   * Consumers (Express/NestJS/Next.js adapters) iterate this with
+   * `for await (const event of stream)` and write SSE frames.
+   */
+  createFlowRunEventStream(flowRunId: string): AsyncGenerator<ExecutionStreamEvent, void, undefined>;
+  /**
+   * Start batch polling for automatic batch completion handling
+   */
+  startBatchPolling(): Promise<void>;
+  /**
+   * Stop batch polling
+   */
+  stopBatchPolling(): Promise<void>;
+  /**
+   * Start the cron scheduler for automatic cron trigger execution.
+   * Call after initialize() — typically in your server startup code.
+   * If cronEnabled is false in InvectConfig.triggers, this is a no-op.
+   */
+  startCronScheduler(): Promise<void>;
+  /**
+   * Stop the cron scheduler. Call during graceful shutdown.
+   */
+  stopCronScheduler(): void;
+  /**
+   * Refresh cron jobs from the database (e.g. after trigger registrations change).
+   */
+  refreshCronScheduler(): Promise<void>;
+  /**
+   * Execute a SQL query for node testing purposes
+   */
+  executeSqlQuery(request: SubmitSQLQueryRequest): Promise<SQLQueryResult>;
+  /**
+   * Test a JS expression in the QuickJS sandbox.
+   * Used by the frontend data mapper preview.
+   */
+  testJsExpression(request: {
+    expression: string;
+    context: Record<string, unknown>;
+  }): Promise<{
+    success: boolean;
+    result?: unknown;
+    error?: string;
+  }>;
+  /**
+   * Test a mapper expression — returns the result plus metadata about how
+   * the node would behave (iterate vs single, item count).
+   * Used by the frontend Data Mapper pane live preview.
+   */
+  testMapper(request: {
+    expression: string;
+    incomingData: Record<string, unknown>;
+    mode?: 'auto' | 'iterate' | 'reshape';
+  }): Promise<{
+    success: boolean;
+    result?: unknown;
+    resultType?: 'array' | 'object' | 'primitive';
+    itemCount?: number;
+    error?: string;
+  }>;
+  /**
+   * Test a model prompt
+   */
+  testModelPrompt(request: SubmitPromptRequest): Promise<unknown>;
+  /**
+   * Get available AI models
+   */
+  getAvailableModels(): Promise<unknown>;
+  /**
+   * Get models for a specific provider
+   */
+  getModelsForProvider(provider: BatchProvider): Promise<{
+    provider: BatchProvider;
+    models: Model[];
+    defaultModel: string;
+  }>;
+  /**
+   * Get models for a credential by detecting its provider
+   */
+  getModelsForCredential(credentialId: string): Promise<{
+    provider: BatchProvider;
+    models: Model[];
+    defaultModel: string;
+  }>;
+  /**
+   * Get available databases
+   */
+  getAvailableDatabases(): InvectDatabaseConfig[];
+  /**
+   * Get definitions for all available nodes.
+   * Returns both legacy node definitions and action-based node definitions.
+   */
+  getAvailableNodes(): NodeDefinition[];
+  /** Get the TemplateService or throw if not initialized. */
+  private getTemplateServiceOrThrow;
+  /**
+   * Resolve {{ expression }} templates in params using the provided context.
+   * Used for test node execution where we need to resolve templates before running.
+   *
+   * @param params - The node parameters to resolve
+   * @param context - The context to use for template resolution
+   * @param skipKeys - Keys to skip (their values should not be resolved as templates)
+   */
+  private resolveTemplateParams;
+  /**
+   * Test/execute a single node with the provided params and input data.
+   * This is useful for testing node configuration in isolation.
+   *
+   * Templates in params (e.g., {{ some_input.data.variables.output.value }})
+   * are resolved using the inputData as context before execution.
+   *
+   * @param nodeType - The type of node to execute
+   * @param params - The node's configuration parameters (may contain {{ }} templates)
+   * @param inputData - Mock input data used both as node inputs and as template context
+   * @returns The node execution result
+   */
+  testNode(nodeType: string, params: Record<string, unknown>, inputData?: Record<string, unknown>): Promise<{
+    success: boolean;
+    output?: Record<string, unknown>;
+    error?: string;
+  }>;
+  /**
+   * Handle node configuration update events coming from the frontend.
+   * Supports both legacy executors (AGENT) and action-based nodes.
+   */
+  handleNodeConfigUpdate(event: NodeConfigUpdateEvent): Promise<NodeConfigUpdateResponse>;
+  /**
+   * Resolve dynamic options for a specific field on an action.
+   *
+   * Called by: `GET /actions/:actionId/fields/:fieldName/options?deps={...}`
+   *
+   * The action's `ParamField.loadOptions.handler` is invoked server-side with
+   * the dependency values and returns an options list + optional default value.
+   */
+  resolveFieldOptions(actionId: string, fieldName: string, dependencyValues: Record<string, unknown>): Promise<LoadOptionsResult>;
+  /**
+   * Render flow to React Flow format
+   */
+  renderToReactFlow(flowId: string, options?: {
+    version?: string | number | 'latest';
+    flowRunId?: string;
+  }): Promise<ReactFlowData>;
+  /**
+   * Get flow service with initialization check
+   */
+  private get flowService();
+  /**
+   * Get flow versions service with initialization check
+   */
+  private get flowVersionsService();
+  /**
+   * Get flow runs service with initialization check
+   */
+  private get flowRunsService();
+  /**
+   * Get orchestration service with initialization check
+   */
+  private get orchestrationService();
+  /**
+   * Get node executions service with initialization check
+   */
+  private get nodeExecutionsService();
+  /**
+   * Get node data service with initialization check
+   */
+  private get nodeDataService();
+  /**
+   * Get base AI client with initialization check
+   */
+  private get baseAIClient();
+  /**
+   * Ensure a provider adapter is registered for the given credential.
+   * Resolves the credential, extracts the API key, detects the provider,
+   * and calls registerAdapter() if not already present.
+   */
+  private ensureAdapterForCredential;
+  /**
+   * Get React Flow renderer service with initialization check
+   */
+  private get reactFlowRendererService();
+  /**
+   * Get credentials service with initialization check
+   */
+  private get credentialsService();
+  /**
+   * Get triggers service with initialization check
+   */
+  private get triggersService();
+  /**
+   * Get credentials service (public accessor)
+   */
+  getCredentialsService(): CredentialsService;
+  /**
+   * Ensure default credentials exist.
+   * Runs once after initialization completes — skips any that already exist by name.
+   */
+  private ensureDefaultCredentials;
+  /**
+   * Initialize services
+   */
+  private initializeServices;
+  /**
+   * Initialize node registry with tool registry
+   */
+  private initializeNodes;
+  /**
+   * Register all actions in the ActionRegistry as agent tools.
+   */
+  private registerActionsAsTools;
+  /**
+   * Ensure core is initialized
+   */
+  private ensureInitialized;
+  /**
+   * Get the action registry.
+   */
+  getActionRegistry(): ActionRegistry;
+  /**
+   * Register an action at runtime (e.g. from a plugin or external package).
+   */
+  registerAction(action: ActionDefinition): void;
+  /**
+   * Get all registered providers.
+   */
+  getProviders(): ProviderDef[];
+  /**
+   * Get all actions for a specific provider.
+   */
+  getActionsForProvider(providerId: string): ActionDefinition[];
+  /**
+   * Get all available agent tools
+   */
+  getAgentTools(): AgentToolDefinition[];
+  /**
+   * Execute agent prompt with tools
+   */
+  submitAgentPrompt(request: SubmitAgentPromptRequest): Promise<AgentPromptResult | {
+    type: 'batch_submitted';
+    batchJobId: string;
+    nodeId: string;
+    flowRunId: string;
+  }>;
+  /**
+   * Create a streaming chat session.
+   *
+   * Returns an AsyncGenerator<ChatStreamEvent> that framework adapters
+   * serialize to SSE. The generator handles the full LLM loop including
+   * tool calls.
+   *
+   * @example
+   * ```typescript
+   * const stream = await invect.createChatStream({
+   *   messages: [{ role: 'user', content: 'Add a Gmail node' }],
+   *   context: { flowId: 'flow_123' },
+   * });
+   *
+   * for await (const event of stream) {
+   *   // event.type: 'text_delta' | 'tool_call_start' | 'tool_call_result' | 'done' | 'error'
+   * }
+   * ```
+   */
+  createChatStream(options: {
+    messages: Array<{
+      role: string;
+      content: string;
+      toolCalls?: unknown[];
+      toolCallId?: string;
+    }>;
+    context: {
+      flowId?: string;
+      selectedNodeId?: string;
+      viewMode?: string;
+      credentialId?: string;
+      maxSteps?: number;
+    };
+    identity?: InvectIdentity;
+  }): Promise<AsyncGenerator<ChatStreamEvent>>;
+  /**
+   * Check if the chat assistant feature is enabled and configured.
+   */
+  isChatEnabled(): boolean;
+  /**
+   * Get all persisted chat messages for a flow (ordered by creation time).
+   */
+  getChatMessages(flowId: string): Promise<ChatMessageRecord[]>;
+  /**
+   * Save chat messages for a flow (replaces existing messages).
+   */
+  saveChatMessages(flowId: string, messages: Array<{
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolMeta?: Record<string, unknown> | null;
+  }>): Promise<ChatMessageRecord[]>;
+  /**
+   * Delete all chat messages for a flow.
+   */
+  deleteChatMessages(flowId: string): Promise<void>;
+  /**
+   * List all trigger registrations for a flow.
+   */
+  listTriggersForFlow(flowId: string): Promise<FlowTriggerRegistration[]>;
+  /**
+   * Get a single trigger registration by ID.
+   */
+  getTrigger(triggerId: string): Promise<FlowTriggerRegistration | null>;
+  /**
+   * Create a trigger registration.
+   */
+  createTrigger(input: CreateTriggerInput): Promise<FlowTriggerRegistration>;
+  /**
+   * Update a trigger registration.
+   */
+  updateTrigger(triggerId: string, input: UpdateTriggerInput): Promise<FlowTriggerRegistration | null>;
+  /**
+   * Delete a trigger registration.
+   */
+  deleteTrigger(triggerId: string): Promise<void>;
+  /**
+   * Sync trigger registrations for a flow from its definition.
+   * Call this after publishing a new flow version. Also refreshes
+   * the cron scheduler if any cron triggers were changed.
+   */
+  syncTriggersForFlow(flowId: string, definition: {
+    nodes: Array<{
+      id: string;
+      type: string;
+      params?: Record<string, unknown>;
+    }>;
+  }): Promise<FlowTriggerRegistration[]>;
+  /**
+   * Get all enabled cron triggers (for scheduler initialization).
+   */
+  getEnabledCronTriggers(): Promise<FlowTriggerRegistration[]>;
+  /**
+   * Execute a cron trigger (called by the cron scheduler).
+   */
+  executeCronTrigger(triggerId: string): Promise<{
+    flowRunId: string;
+    flowId: string;
+  }>;
+  /**
+   * Get all available OAuth2 providers
+   */
+  getOAuth2Providers(): OAuth2ProviderDefinition[];
+  /**
+   * Get a specific OAuth2 provider by ID
+   */
+  getOAuth2Provider(providerId: string): OAuth2ProviderDefinition | undefined;
+  /**
+   * Start an OAuth2 authorization flow
+   * Returns the authorization URL and state to redirect the user to
+   */
+  startOAuth2Flow(providerId: string, appConfig: {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+  }, options?: {
+    scopes?: string[];
+    returnUrl?: string;
+    credentialName?: string;
+  }): OAuth2StartResult;
+  /**
+   * Get pending OAuth2 state (for verifying callback)
+   */
+  getOAuth2PendingState(state: string): OAuth2PendingState | undefined;
+  /**
+   * Handle OAuth2 callback - exchange code for tokens and create credential
+   */
+  handleOAuth2Callback(code: string, state: string, appConfig: {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+  }): Promise<Credential>;
+  /**
+   * Refresh an OAuth2 credential's access token
+   */
+  refreshOAuth2Credential(credentialId: string): Promise<Credential>;
+}
+//#endregion
+export { CoreInitializationStatus, CustomNodeConfig, DashboardStats, Invect };
+//# sourceMappingURL=invect-core.d.cts.map