@clusterenvision/ui-framework 1.0.0

package/dist/index-CpxDa60m.d.ts

@@ -0,0 +1,644 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogErrorPayload {
+    name?: string;
+    message: string;
+    stack?: string;
+    cause?: unknown;
+}
+interface LogContext extends Record<string, unknown> {
+    eventId?: string;
+    scope?: string;
+    workflowId?: string;
+    workflowVersion?: string;
+    runId?: string;
+    stepId?: string;
+    taskName?: string;
+    attempt?: number;
+    actorId?: string;
+    delayMs?: number;
+}
+interface LogEvent {
+    level: LogLevel;
+    message: string;
+    context?: LogContext;
+    error?: LogErrorPayload;
+    timestamp?: Date;
+}
+interface Logger {
+    log(event: LogEvent): void;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+declare class ConsoleLogger implements Logger {
+    private readonly scope: string;
+    private readonly writer: Record<LogLevel, (message?: unknown, ...optionalParams: unknown[]) => void>;
+    constructor(scope?: string, writer?: Record<LogLevel, (message?: unknown, ...optionalParams: unknown[]) => void>);
+    log(event: LogEvent): void;
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+
+type WorkflowStatus = 'pending' | 'running' | 'waiting' | 'completed' | 'failed' | 'terminated';
+interface ActorContext {
+    id: string;
+    roles?: string[];
+    scopes?: string[];
+    attributes?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface ApprovalGate {
+    id: string;
+    approvers?: string[];
+    requiredRoles?: string[];
+    strategy?: 'any' | 'all';
+    metadata?: Record<string, unknown>;
+}
+interface ApprovalDecision {
+    status: 'approved' | 'rejected' | 'pending';
+    decidedBy?: string;
+    decidedAt?: Date;
+    reason?: string;
+}
+interface ApprovalContext {
+    actor?: ActorContext;
+    instance: WorkflowInstanceState;
+    step: WorkflowStepDefinition;
+}
+interface ApprovalResolver {
+    resolve(gate: ApprovalGate, context: ApprovalContext): Promise<ApprovalDecision> | ApprovalDecision;
+}
+interface RetryPolicy {
+    maxAttempts?: number;
+    delayMs?: number;
+    maxDelayMs?: number;
+    backoff?: 'fixed' | 'exponential' | 'jitter';
+}
+interface WorkflowTransitions {
+    success?: string;
+    failure?: string;
+}
+interface TaskInvocation {
+    handler: string;
+    input?: Record<string, unknown>;
+}
+interface WorkflowStepDefinition {
+    id: string;
+    task: TaskInvocation;
+    transitions?: WorkflowTransitions;
+    retry?: RetryPolicy;
+    approvals?: ApprovalGate[];
+    metadata?: Record<string, unknown>;
+}
+interface WorkflowDefinition {
+    name: string;
+    version: string;
+    entry: string;
+    steps: Record<string, WorkflowStepDefinition>;
+    metadata?: Record<string, unknown>;
+}
+type WorkflowState = Record<string, unknown>;
+interface WorkflowHistoryEntry {
+    stepId: string;
+    status: 'success' | 'failure';
+    attempt: number;
+    timestamp: Date;
+    notes?: string;
+}
+interface WorkflowInstanceState {
+    id: string;
+    workflowId: string;
+    version: string;
+    status: WorkflowStatus;
+    currentStep?: string;
+    state: WorkflowState;
+    actor?: ActorContext;
+    metadata?: Record<string, unknown>;
+    history: WorkflowHistoryEntry[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface WorkflowTaskContext {
+    runId: string;
+    instanceId: string;
+    definition: WorkflowDefinition;
+    step: WorkflowStepDefinition;
+    input?: Record<string, unknown>;
+    state: WorkflowState;
+    actor?: ActorContext;
+    services: WorkflowServices;
+    logger?: WorkflowLogger;
+    trace?: WorkflowTraceSink;
+}
+interface WorkflowTaskResult {
+    status: 'success' | 'failure';
+    data?: Record<string, unknown>;
+    transition?: string;
+    error?: unknown;
+}
+type WorkflowTaskHandler = (context: WorkflowTaskContext) => Promise<WorkflowTaskResult> | WorkflowTaskResult;
+interface WorkflowStore {
+    save(instance: WorkflowInstanceState): Promise<void>;
+    load?(id: string): Promise<WorkflowInstanceState | null>;
+}
+interface WorkflowRunRequest {
+    instanceId?: string;
+    actor?: ActorContext;
+    state?: WorkflowState;
+    metadata?: Record<string, unknown>;
+}
+interface WorkflowRunResult {
+    instance: WorkflowInstanceState;
+    status: WorkflowStatus;
+    output?: Record<string, unknown>;
+}
+interface WorkflowRuntimeOptions {
+    store: WorkflowStore;
+    tasks?: Record<string, WorkflowTaskHandler>;
+    services?: Partial<WorkflowServices>;
+    approvalResolver?: ApprovalResolver;
+    logger?: WorkflowLogger;
+    idGenerator?: () => string;
+    traceSink?: WorkflowTraceSink;
+}
+interface WorkflowServices {
+    http?: HttpTaskExecutor;
+    databases?: DatabaseRegistry;
+    background?: BackgroundRunner;
+    time?: TimeService;
+    scheduler?: WorkflowScheduler;
+    trace?: WorkflowTraceSink;
+}
+type WorkflowLogger = Logger;
+type WorkflowTraceEventType = 'workflow.run.started' | 'workflow.run.waiting' | 'workflow.run.completed' | 'workflow.run.failed' | 'workflow.step.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.step.retry' | 'workflow.approval.requested' | 'workflow.approval.resolved' | 'workflow.scheduler.dispatched';
+interface WorkflowTraceEvent {
+    type: WorkflowTraceEventType;
+    timestamp: Date;
+    workflowId: string;
+    workflowVersion: string;
+    instanceId: string;
+    stepId?: string;
+    runId?: string;
+    attempt?: number;
+    gateId?: string;
+    approvalStatus?: ApprovalDecision['status'];
+    durationMs?: number;
+    delayMs?: number;
+    actorId?: string;
+    attributes?: Record<string, unknown>;
+}
+interface WorkflowTraceSink {
+    record(event: WorkflowTraceEvent): void | Promise<void>;
+}
+interface HttpTaskRequest {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean>;
+    body?: unknown;
+    timeoutMs?: number;
+}
+interface HttpTaskResponse {
+    status: number;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+type HttpTaskExecutor = (request: HttpTaskRequest, context: WorkflowTaskContext) => Promise<HttpTaskResponse>;
+type DatabaseOperationType = 'query' | 'command' | 'transaction';
+interface DatabaseOperation {
+    type: DatabaseOperationType;
+    text?: string;
+    parameters?: unknown[];
+    collection?: string;
+    filter?: Record<string, unknown>;
+    payload?: Record<string, unknown>;
+}
+interface DatabaseProviderContext {
+    actor?: ActorContext;
+    metadata?: Record<string, unknown>;
+}
+interface DatabaseProvider {
+    name: string;
+    execute<T = unknown>(operation: DatabaseOperation, context?: DatabaseProviderContext): Promise<T>;
+}
+interface DatabaseRegistry {
+    register(provider: DatabaseProvider): void;
+    get(name: string): DatabaseProvider | undefined;
+    list(): string[];
+}
+interface BackgroundRunner {
+    dispatch(taskName: string, payload?: Record<string, unknown>): Promise<void>;
+}
+interface TimeService {
+    wait(ms: number): Promise<void>;
+    now(): Date;
+}
+interface ScheduleRequest {
+    taskName: string;
+    payload?: Record<string, unknown>;
+    runAt?: Date;
+    delayMs?: number;
+    description?: string;
+}
+interface WorkflowScheduler {
+    schedule(request: ScheduleRequest, context: WorkflowTaskContext): Promise<void>;
+}
+type WorkflowJSONDefinition = WorkflowDefinition;
+interface WorkflowDefinitionSerializer {
+    serialize(definition: WorkflowDefinition): WorkflowJSONDefinition;
+    deserialize(json: WorkflowJSONDefinition): WorkflowDefinition;
+}
+interface PolicyEvaluationRequest {
+    actor?: ActorContext;
+    instance: WorkflowInstanceState;
+    step?: WorkflowStepDefinition;
+    action: 'start' | 'step' | 'approve';
+    metadata?: Record<string, unknown>;
+}
+interface PolicyDecision {
+    allow: boolean;
+    reason?: string;
+    obligations?: Record<string, unknown>;
+}
+interface WorkflowPolicyEngine {
+    evaluate(request: PolicyEvaluationRequest): Promise<PolicyDecision> | PolicyDecision;
+}
+interface QueueMessage {
+    id?: string;
+    name: string;
+    payload?: Record<string, unknown>;
+    runAt?: Date;
+}
+interface QueueMetricsEmitter {
+    record(event: 'enqueued' | 'dispatched' | 'failed', metadata?: Record<string, unknown>): void;
+}
+interface QueueDriver {
+    enqueue(message: QueueMessage): Promise<void>;
+    schedule?(message: QueueMessage): Promise<void>;
+}
+type TokenClaims = Record<string, unknown>;
+type ActorMapper = (claims: TokenClaims) => ActorContext;
+type WorkflowAuthMiddleware = (request: PolicyEvaluationRequest) => Promise<void> | void;
+
+declare class WorkflowRuntime {
+    private readonly options;
+    private readonly tasks;
+    private readonly services;
+    private readonly approvalResolver;
+    private readonly logger;
+    private readonly idGenerator;
+    constructor(options: WorkflowRuntimeOptions);
+    registerTask(name: string, handler: WorkflowTaskHandler): void;
+    hasTask(name: string): boolean;
+    listTasks(): string[];
+    run(definition: WorkflowDefinition, request?: WorkflowRunRequest): Promise<WorkflowRunResult>;
+    private executeStep;
+    private normalizeRetry;
+    private resolveTask;
+    private buildHistoryEntry;
+    private ensureApprovals;
+    private waitForRetry;
+    private persist;
+}
+
+declare function createWorkflow(name: string, configure: (builder: WorkflowBuilder) => void, options?: {
+    version?: string;
+    entry?: string;
+    metadata?: Record<string, unknown>;
+}): WorkflowDefinition;
+declare class WorkflowBuilder {
+    private readonly workflowName;
+    private versionValue;
+    private readonly steps;
+    private entryStep?;
+    private metadataValue?;
+    constructor(workflowName: string, versionValue: string);
+    version(value: string): this;
+    entry(stepId: string): this;
+    metadata(data: Record<string, unknown>): this;
+    step(id: string, task: TaskInvocation, configure?: (step: WorkflowStepBuilder) => void): this;
+    build(): WorkflowDefinition;
+}
+declare class WorkflowStepBuilder {
+    private readonly parent;
+    private readonly definition;
+    constructor(parent: WorkflowBuilder, definition: WorkflowStepDefinition);
+    onSuccess(stepId: string): this;
+    onFailure(stepId: string): this;
+    withRetry(policy: RetryPolicy): this;
+    withApproval(gate: ApprovalGate): this;
+    metadata(data: Record<string, unknown>): this;
+    end(): WorkflowBuilder;
+}
+declare function task(handler: string, input?: Record<string, unknown>): TaskInvocation;
+declare function workflowFromJson(json: WorkflowJSONDefinition): WorkflowDefinition;
+
+declare const HTTP_TASK = "workflow.http.request";
+declare const DATABASE_TASK = "workflow.database.execute";
+declare const DELAY_TASK = "workflow.time.delay";
+declare const SCHEDULE_TASK = "workflow.background.schedule";
+interface HttpTaskInput extends HttpTaskRequest, Record<string, unknown> {
+    assignResponseTo?: string;
+    parse?: 'json' | 'text' | 'auto';
+}
+interface DatabaseTaskInput extends Record<string, unknown> {
+    provider: string;
+    operation: DatabaseOperation;
+    assignResultTo?: string;
+}
+interface DelayTaskInput extends Record<string, unknown> {
+    milliseconds?: number;
+    seconds?: number;
+}
+interface ScheduleTaskInput extends Record<string, unknown> {
+    taskName: string;
+    payload?: Record<string, unknown>;
+    runAt?: string | Date;
+    delayMs?: number;
+    description?: string;
+}
+declare function httpTask(options: HttpTaskInput): TaskInvocation;
+declare function databaseTask(options: DatabaseTaskInput): TaskInvocation;
+declare function delayTask(options: DelayTaskInput): TaskInvocation;
+declare function scheduleTask(options: ScheduleTaskInput): TaskInvocation;
+declare function createDefaultTaskMap(executor?: HttpTaskExecutor): Record<string, WorkflowTaskHandler>;
+declare function createHttpTaskHandler(fallback?: HttpTaskExecutor): WorkflowTaskHandler;
+declare function createDatabaseTaskHandler(): WorkflowTaskHandler;
+declare function createDelayTaskHandler(): WorkflowTaskHandler;
+declare function createScheduleTaskHandler(): WorkflowTaskHandler;
+type FetchLike = (url: string, init?: FetchInit) => Promise<FetchResponse>;
+interface FetchInit {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+interface FetchResponse {
+    status: number;
+    headers?: {
+        forEach(callback: (value: string, key: string) => void): void;
+    };
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+declare function createFetchHttpExecutor(fetchImpl?: FetchLike): HttpTaskExecutor;
+declare class FunctionalDatabaseProvider implements DatabaseProvider {
+    readonly name: string;
+    private readonly executor;
+    constructor(name: string, executor: (operation: DatabaseOperation, context?: DatabaseProviderContext) => Promise<unknown>);
+    execute<T = unknown>(operation: DatabaseOperation, context?: DatabaseProviderContext): Promise<T>;
+}
+declare function createSqlDatabaseProvider(options: {
+    name: string;
+    query: (sql: string, parameters?: unknown[]) => Promise<unknown>;
+}): DatabaseProvider;
+declare function createMySqlProvider(client: {
+    query: (sql: string, values?: unknown[]) => Promise<unknown>;
+}, name?: string): DatabaseProvider;
+declare function createPostgresProvider(client: {
+    query: (sql: string, values?: unknown[]) => Promise<unknown>;
+}, name?: string): DatabaseProvider;
+declare function createSqliteProvider(client: {
+    run: (sql: string, values?: unknown[]) => Promise<unknown>;
+}, name?: string): DatabaseProvider;
+declare function createMongoProvider(options: {
+    name?: string;
+    run: (operation: DatabaseOperation) => Promise<unknown>;
+}): DatabaseProvider;
+declare function registerDefaultDatabaseProviders(registry: DatabaseRegistry, providers: DatabaseProvider[]): void;
+
+declare class SystemTimeService implements TimeService {
+    wait(ms: number): Promise<void>;
+    now(): Date;
+}
+declare class DefaultBackgroundRunner implements BackgroundRunner {
+    private readonly logger;
+    constructor(logger?: WorkflowLogger);
+    dispatch(taskName: string, payload?: Record<string, unknown>): Promise<void>;
+}
+declare class InMemoryWorkflowStore implements WorkflowStore {
+    private readonly instances;
+    save(instance: WorkflowInstanceState): Promise<void>;
+    load(id: string): Promise<WorkflowInstanceState | null>;
+}
+declare class InMemorySchedulerService implements WorkflowScheduler {
+    private readonly background;
+    private readonly time;
+    private readonly logger;
+    private readonly trace?;
+    constructor(background?: BackgroundRunner, time?: TimeService, logger?: WorkflowLogger, trace?: WorkflowTraceSink);
+    schedule(request: ScheduleRequest, context: WorkflowTaskContext): Promise<void>;
+}
+declare class InMemoryDatabaseRegistry implements DatabaseRegistry {
+    private readonly providers;
+    register(provider: DatabaseProvider): void;
+    get(name: string): DatabaseProvider | undefined;
+    list(): string[];
+}
+declare class DefaultApprovalResolver implements ApprovalResolver {
+    resolve(gate: ApprovalGate, context: ApprovalContext): Promise<ApprovalDecision>;
+}
+declare class ConsoleWorkflowLogger extends ConsoleLogger implements WorkflowLogger {
+    constructor();
+}
+
+type SqlDialect = 'postgres' | 'mysql' | 'sqlite';
+interface DatabaseWorkflowStoreOptions {
+    provider: DatabaseProvider;
+    table?: string;
+    dialect?: SqlDialect;
+}
+declare class DatabaseWorkflowStore implements WorkflowStore {
+    private readonly options;
+    private readonly table;
+    private readonly dialect;
+    constructor(options: DatabaseWorkflowStoreOptions);
+    save(instance: WorkflowInstanceState): Promise<void>;
+    load(id: string): Promise<WorkflowInstanceState | null>;
+}
+
+interface MongoCollectionLike<T> {
+    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    findOne(filter: Record<string, unknown>): Promise<T | null>;
+    createIndex?(keys: Record<string, 1 | -1>, options?: Record<string, unknown>): Promise<string>;
+}
+interface MongoWorkflowStoreOptions {
+    collection: MongoCollectionLike<WorkflowDocument>;
+    createIndexes?: boolean;
+}
+interface WorkflowDocument {
+    _id: string;
+    workflowId: string;
+    version: string;
+    status: WorkflowStatus;
+    currentStep?: string;
+    state: WorkflowState;
+    actor?: ActorContext;
+    metadata?: Record<string, unknown>;
+    history: WorkflowDocumentHistoryEntry[];
+    createdAt: string;
+    updatedAt: string;
+}
+type WorkflowDocumentHistoryEntry = Omit<WorkflowHistoryEntry, 'timestamp'> & {
+    timestamp: string;
+};
+declare class MongoWorkflowStore implements WorkflowStore {
+    private readonly options;
+    constructor(options: MongoWorkflowStoreOptions);
+    save(instance: WorkflowInstanceState): Promise<void>;
+    load(id: string): Promise<WorkflowInstanceState | null>;
+    private ensureIndexes;
+}
+
+interface VisualWorkflowSchema {
+    id: string;
+    name: string;
+    version: string;
+    entry: string;
+    metadata?: Record<string, unknown>;
+    nodes: VisualWorkflowNode[];
+    edges: VisualWorkflowEdge[];
+}
+interface VisualWorkflowNode {
+    id: string;
+    label: string;
+    task: TaskInvocation;
+    position?: {
+        x: number;
+        y: number;
+    };
+    size?: {
+        width: number;
+        height: number;
+    };
+    data?: Record<string, unknown>;
+    approvals?: WorkflowStepDefinition['approvals'];
+    retry?: WorkflowStepDefinition['retry'];
+    metadata?: Record<string, unknown>;
+}
+interface VisualWorkflowEdge {
+    id: string;
+    source: string;
+    target: string;
+    when?: 'success' | 'failure';
+    label?: string;
+    metadata?: Record<string, unknown>;
+}
+declare function workflowToVisualSchema(definition: WorkflowDefinition): VisualWorkflowSchema;
+declare function visualSchemaToWorkflow(schema: VisualWorkflowSchema): WorkflowDefinition;
+
+interface PrismaClientLike {
+    $queryRawUnsafe<T = unknown>(query: string, ...params: unknown[]): Promise<T>;
+    $executeRawUnsafe?(query: string, ...params: unknown[]): Promise<unknown>;
+}
+declare function createPrismaProvider(options: {
+    name?: string;
+    client: PrismaClientLike;
+}): DatabaseProvider;
+interface DrizzleClientLike {
+    execute<T = unknown>(query: string, params?: unknown[]): Promise<T>;
+}
+declare function createDrizzleProvider(options: {
+    name?: string;
+    client: DrizzleClientLike;
+}): DatabaseProvider;
+interface SupabaseClientLike {
+    from(table: string): {
+        select(columns?: string): SupabaseQueryLike;
+        insert(payload: unknown): SupabaseQueryLike;
+        update(payload: unknown): SupabaseQueryLike;
+        delete(): SupabaseQueryLike;
+    };
+    rpc?(fn: string, params?: Record<string, unknown>): Promise<unknown>;
+}
+interface SupabaseQueryLike {
+    eq?(column: string, value: unknown): SupabaseQueryLike;
+    match?(criteria: Record<string, unknown>): SupabaseQueryLike;
+    limit?(value: number): SupabaseQueryLike;
+    single?(): SupabaseQueryLike;
+    select?(columns?: string): SupabaseQueryLike;
+    order?(column: string, options?: Record<string, unknown>): SupabaseQueryLike;
+    then<TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+declare function createSupabaseProvider(options: {
+    name?: string;
+    client: SupabaseClientLike;
+}): DatabaseProvider;
+interface RestDatabaseAdapterOptions {
+    name?: string;
+    endpoint: string;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    headers?: Record<string, string>;
+}
+declare function createRestDatabaseProvider(options: RestDatabaseAdapterOptions): DatabaseProvider;
+
+interface QueueBackgroundRunnerOptions {
+    driver: QueueDriver;
+    metrics?: QueueMetricsEmitter;
+}
+declare class QueueBackgroundRunner implements BackgroundRunner, WorkflowScheduler {
+    private readonly options;
+    constructor(options: QueueBackgroundRunnerOptions);
+    dispatch(taskName: string, payload?: Record<string, unknown>): Promise<void>;
+    schedule(request: ScheduleRequest, context: WorkflowTaskContext): Promise<void>;
+}
+interface BullMqDriver {
+    add(name: string, payload?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+}
+declare function createBullMqDriver(queue: BullMqDriver): QueueDriver;
+interface SqsClientLike {
+    sendMessage(params: Record<string, unknown>): Promise<unknown>;
+}
+declare function createSqsDriver(client: SqsClientLike, queueUrl: string): QueueDriver;
+interface AzureQueueClientLike {
+    sendMessage(message: string, options?: Record<string, unknown>): Promise<unknown>;
+}
+declare function createAzureQueueDriver(client: AzureQueueClientLike): QueueDriver;
+declare class MetricsConsoleEmitter implements QueueMetricsEmitter {
+    record(event: 'enqueued' | 'dispatched' | 'failed', metadata?: Record<string, unknown>): void;
+}
+
+declare class PolicyApprovalResolver implements ApprovalResolver {
+    private readonly engine;
+    private readonly fallback?;
+    constructor(engine: WorkflowPolicyEngine, fallback?: ApprovalResolver | undefined);
+    resolve(gate: ApprovalGate, context: ApprovalContext): Promise<ApprovalDecision>;
+}
+interface SimplePolicyRule {
+    match: (request: PolicyEvaluationRequest) => boolean;
+    decision: (request: PolicyEvaluationRequest) => PolicyDecision;
+}
+declare class RuleBasedPolicyEngine implements WorkflowPolicyEngine {
+    private readonly rules;
+    private readonly defaultDecision;
+    constructor(rules: SimplePolicyRule[], defaultDecision?: PolicyDecision);
+    evaluate(request: PolicyEvaluationRequest): PolicyDecision;
+}
+declare function actorFromOidcClaims(claims: Record<string, unknown>, mapping?: ActorClaimMapping): ActorContext;
+declare function actorFromCognitoClaims(claims: Record<string, unknown>): ActorContext;
+declare function actorFromAzureAdClaims(claims: Record<string, unknown>): ActorContext;
+declare function actorFromAuth0Claims(claims: Record<string, unknown>): ActorContext;
+interface ActorClaimMapping {
+    provider?: string;
+    idClaim?: string;
+    rolesClaim?: string;
+    scopesClaim?: string;
+    attributeClaims?: string[];
+    includeRaw?: boolean;
+}
+declare function requireActorRoles(roles: string[]): WorkflowAuthMiddleware;
+declare function requireActorScopes(scopes: string[]): WorkflowAuthMiddleware;
+declare function runAuthMiddleware(middleware: WorkflowAuthMiddleware[], request: PolicyEvaluationRequest): Promise<void>;
+declare function createStartWorkflowMiddleware(sequence: WorkflowAuthMiddleware[]): WorkflowAuthMiddleware;
+declare function createStepMiddleware(sequence: WorkflowAuthMiddleware[]): WorkflowAuthMiddleware;
+declare function multiStepApprovalResolver(resolvers: ApprovalResolver[]): ApprovalResolver;
+declare class ManualOverrideApprovalResolver implements ApprovalResolver {
+    private readonly overrides;
+    constructor(overrides: Map<string, ApprovalDecision>);
+    resolve(gate: ApprovalGate, context: ApprovalContext): ApprovalDecision;
+}
+declare function buildPolicyRequest(instance: WorkflowInstanceState, step: WorkflowStepDefinition, actor?: ActorContext): PolicyEvaluationRequest;
+
+export { type QueueBackgroundRunnerOptions as $, type ActorClaimMapping as A, type BackgroundRunner as B, ConsoleLogger as C, DATABASE_TASK as D, type HttpTaskRequest as E, FunctionalDatabaseProvider as F, type HttpTaskResponse as G, HTTP_TASK as H, InMemoryDatabaseRegistry as I, InMemorySchedulerService as J, InMemoryWorkflowStore as K, type LogContext as L, type LogErrorPayload as M, type LogEvent as N, type LogLevel as O, type Logger as P, ManualOverrideApprovalResolver as Q, MetricsConsoleEmitter as R, type MongoCollectionLike as S, MongoWorkflowStore as T, type MongoWorkflowStoreOptions as U, PolicyApprovalResolver as V, type WorkflowTraceSink as W, type PolicyDecision as X, type PolicyEvaluationRequest as Y, type PrismaClientLike as Z, QueueBackgroundRunner as _, type WorkflowLogger as a, createScheduleTaskHandler as a$, type QueueDriver as a0, type QueueMessage as a1, type QueueMetricsEmitter as a2, type RestDatabaseAdapterOptions as a3, type RetryPolicy as a4, RuleBasedPolicyEngine as a5, SCHEDULE_TASK as a6, type ScheduleRequest as a7, type ScheduleTaskInput as a8, type SimplePolicyRule as a9, type WorkflowStatus as aA, WorkflowStepBuilder as aB, type WorkflowStepDefinition as aC, type WorkflowStore as aD, type WorkflowTaskContext as aE, type WorkflowTaskHandler as aF, type WorkflowTaskResult as aG, type WorkflowTraceEventType as aH, type WorkflowTransitions as aI, actorFromAuth0Claims as aJ, actorFromAzureAdClaims as aK, actorFromCognitoClaims as aL, actorFromOidcClaims as aM, buildPolicyRequest as aN, createAzureQueueDriver as aO, createBullMqDriver as aP, createDatabaseTaskHandler as aQ, createDefaultTaskMap as aR, createDelayTaskHandler as aS, createDrizzleProvider as aT, createFetchHttpExecutor as aU, createHttpTaskHandler as aV, createMongoProvider as aW, createMySqlProvider as aX, createPostgresProvider as aY, createPrismaProvider as aZ, createRestDatabaseProvider as a_, type SqlDialect as aa, type SqsClientLike as ab, type SupabaseClientLike as ac, type SupabaseQueryLike as ad, SystemTimeService as ae, type TaskInvocation as af, type TimeService as ag, type TokenClaims as ah, type VisualWorkflowEdge as ai, type VisualWorkflowNode as aj, type VisualWorkflowSchema as ak, type WorkflowAuthMiddleware as al, WorkflowBuilder as am, type WorkflowDefinition as an, type WorkflowDefinitionSerializer as ao, type WorkflowHistoryEntry as ap, type WorkflowInstanceState as aq, type WorkflowJSONDefinition as ar, type WorkflowPolicyEngine as as, type WorkflowRunRequest as at, type WorkflowRunResult as au, WorkflowRuntime as av, type WorkflowRuntimeOptions as aw, type WorkflowScheduler as ax, type WorkflowServices as ay, type WorkflowState as az, type WorkflowTraceEvent as b, createSqlDatabaseProvider as b0, createSqliteProvider as b1, createSqsDriver as b2, createStartWorkflowMiddleware as b3, createStepMiddleware as b4, createSupabaseProvider as b5, createWorkflow as b6, databaseTask as b7, delayTask as b8, httpTask as b9, multiStepApprovalResolver as ba, registerDefaultDatabaseProviders as bb, requireActorRoles as bc, requireActorScopes as bd, runAuthMiddleware as be, scheduleTask as bf, task as bg, visualSchemaToWorkflow as bh, workflowFromJson as bi, workflowToVisualSchema as bj, type ActorContext as c, type ActorMapper as d, type ApprovalContext as e, type ApprovalDecision as f, type ApprovalGate as g, type ApprovalResolver as h, type AzureQueueClientLike as i, type BullMqDriver as j, ConsoleWorkflowLogger as k, DELAY_TASK as l, type DatabaseOperation as m, type DatabaseOperationType as n, type DatabaseProvider as o, type DatabaseProviderContext as p, type DatabaseRegistry as q, type DatabaseTaskInput as r, DatabaseWorkflowStore as s, type DatabaseWorkflowStoreOptions as t, DefaultApprovalResolver as u, DefaultBackgroundRunner as v, type DelayTaskInput as w, type DrizzleClientLike as x, type HttpTaskExecutor as y, type HttpTaskInput as z };