import { a as CollectionDefinition, i as Engine, n as OAuthFlowExecutor, s as Clock, t as CredentialMaterialProvider } from "./index-Cy08dvyb.js";
import { $ as RunEventBus, A as RunId, At as WorkflowRunDetailDto, G as RunSummary, It as WorkflowId, J as Container, L as PersistedRunState, P as WorkflowDefinition, S as Items, V as RunPruneCandidate, X as TypeToken, _ as WorkflowRepository, ct as AnyCredentialType, et as TestCaseRunStatus, h as NodeExecutionScheduler, k as PersistedRunPolicySnapshot, m as NodeExecutionRequestHandler, o as BinaryStorage, ot as WorkflowActivationPolicy, st as McpServerDeclaration, z as RunCurrentState } from "./ItemsInputNormalizer-C2gLv7d9.js";
import { C as CodemationContainerRegistration, l as CodemationPluginPackageMetadata, o as CodemationPlugin, r as AppConfig } from "./CodemationAppContext-CA4xzGA6.js";
import { a as CodemationAuthConfig, l as Logger, t as CodemationWhitelabelConfig, u as LoggerFactory } from "./CodemationWhitelabelConfig-CPKKZwGp.js";
import { t as LogLevelPolicyFactory } from "./LogLevelPolicyFactory-Cu5Ef_mL.js";
import { t as CredentialStore } from "./CredentialServices-vjUDU7PW.js";
import { i as TelemetryMetricPointStore, n as TelemetryArtifactStore, o as TelemetrySpanStore, r as TelemetryExporter, s as TelemetrySpanUpsert, t as RunTraceContextRepository } from "./TelemetryContracts-CfeVZRFL.js";
import { n as PrismaDatabaseClient } from "./AppConfigFactory-DZjtXivd.js";
import { t as PrismaMigrationDeployer } from "./PrismaMigrationDeployer-BoM4dvIC.js";
import { t as InternalHonoApiRouteRegistrar } from "./InternalHonoApiRouteRegistrar-Ck5-r6yB.js";
import { s as ProcessRunner } from "./PublicFrontendBootstrapFactory-DDz0bVIV.js";
import "reflect-metadata";
import { Hono, MiddlewareHandler } from "hono";

//#region src/application/bus/Command.d.ts
declare abstract class Command<TResult> {
  protected readonly __resultType?: TResult;
}
//#endregion
//#region src/application/bus/CommandBus.d.ts
interface CommandBus {
  execute<TResult>(command: Command<TResult>): Promise<TResult>;
}
//#endregion
//#region src/application/bus/Query.d.ts
declare abstract class Query<TResult> {
  protected readonly __resultType?: TResult;
}
//#endregion
//#region src/application/bus/QueryBus.d.ts
interface QueryBus {
  execute<TResult>(query: Query<TResult>): Promise<TResult>;
}
//#endregion
//#region src/infrastructure/config/CodemationPluginRegistrar.d.ts
declare class CodemationPluginRegistrar {
  apply(args: Readonly<{
    plugins: ReadonlyArray<CodemationPlugin>;
    container: Container;
    appConfig: AppConfig;
    registerCredentialType: (type: AnyCredentialType) => void;
    registerCollection: (definition: CollectionDefinition) => void;
    mergeMcpServers: (declarations: ReadonlyArray<McpServerDeclaration>) => void;
    loggerFactory: LoggerFactory;
  }>): Promise<void>;
}
//#endregion
//#region src/bootstrap/CodemationContainerRegistrationRegistrar.d.ts
declare class CodemationContainerRegistrationRegistrar {
  apply(container: Container, registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>): void;
  private applyRegistration;
  private isValueRegistration;
  private isClassRegistration;
}
//#endregion
//#region src/bootstrap/AppContainerFactory.d.ts
type AppContainerInputs = Readonly<{
  appConfig: AppConfig;
}>;
declare class AppContainerFactory {
  private readonly containerRegistrationRegistrar;
  private readonly pluginRegistrar;
  private static readonly queryHandlers;
  private static readonly commandHandlers;
  private static readonly honoRouteRegistrars;
  constructor(containerRegistrationRegistrar?: CodemationContainerRegistrationRegistrar, pluginRegistrar?: CodemationPluginRegistrar);
  create(inputs: AppContainerInputs): Promise<Container>;
  private collectCredentialTypes;
  private registerMcpCatalog;
  private mergeConfigMcpServers;
  private applyPlugins;
  private registerCredentialTypes;
  private registerControlPlaneCatalogFetcher;
  private registerConfiguredRegistrations;
  private registerCollectionsInfrastructure;
  private registerCoreInfrastructure;
  private registerRepositoriesAndBuses;
  private registerApplicationServicesAndRoutes;
  private registerManagedAuthInfrastructure;
  private registerPairingInfrastructure;
  private registerOperationalInfrastructure;
  private registerWorkflowAuditWriter;
  private registerRuntimeInfrastructure;
  private resolvePrismaOwnership;
  private registerRuntimeNodeActivationScheduler;
  private createWorkflowPolicyRuntimeDefaults;
  private createBinaryStorage;
  private createWorkspaceFileStorage;
  private createRuntimeSummary;
  private requireRedisUrl;
  private readPositiveInteger;
  private synchronizeLiveWorkflowRepository;
}
//#endregion
//#region src/bootstrap/AppContainerLifecycle.d.ts
declare class AppContainerLifecycle {
  private readonly container;
  private readonly ownedPrismaClient;
  constructor(container: Container, ownedPrismaClient: PrismaDatabaseClient | null);
  start(): Promise<void>;
  startWorkerSubscribers(): Promise<void>;
  stop(): Promise<void>;
}
//#endregion
//#region src/bootstrap/runtime/DatabaseMigrations.d.ts
declare class DatabaseMigrations {
  private readonly appConfig;
  private readonly prismaMigrationDeployer;
  constructor(appConfig: AppConfig, prismaMigrationDeployer: PrismaMigrationDeployer);
  migrate(): Promise<void>;
}
//#endregion
//#region src/infrastructure/collections/CollectionAdvisoryLockService.types.d.ts
interface CollectionAdvisoryLockService {
  withLock<T>(key: string, fn: () => Promise<T>): Promise<T>;
}
//#endregion
//#region src/infrastructure/collections/collectionSchemaTypes.d.ts
interface ColumnSpec {
  readonly name: string;
  readonly type: "uuid" | "text" | "integer" | "bigint" | "double" | "boolean" | "timestamptz" | "jsonb";
  readonly nullable: boolean;
  readonly default?: unknown;
}
interface IndexSpec {
  readonly name: string;
  readonly fields: ReadonlyArray<string>;
  readonly unique: boolean;
}
interface LiveCollectionTable {
  readonly columns: ReadonlyArray<ColumnSpec>;
  readonly indexes: ReadonlyArray<IndexSpec>;
}
interface LiveCollectionsSchema {
  readonly tables: Readonly<Record<string, LiveCollectionTable>>;
}
interface DiffOps {
  readonly collection: string;
  readonly createTable?: ReadonlyArray<ColumnSpec>;
  readonly addColumns: ReadonlyArray<ColumnSpec>;
  readonly dropColumns: ReadonlyArray<string>;
  readonly addIndexes: ReadonlyArray<IndexSpec>;
  readonly dropIndexes: ReadonlyArray<string>;
}
interface CollectionSyncResult {
  readonly planned: ReadonlyArray<DiffOps>;
  readonly applied: ReadonlyArray<DiffOps>;
}
//#endregion
//#region src/infrastructure/collections/CollectionDdlEmitter.types.d.ts
interface CollectionDdlEmitter {
  createSchemaSql(): string | null;
  createTableSql(definition: CollectionDefinition, columns: ReadonlyArray<ColumnSpec>): string;
  addColumnSql(definition: CollectionDefinition, column: ColumnSpec): string;
  dropColumnSql(definition: CollectionDefinition, columnName: string): string;
  createIndexSql(definition: CollectionDefinition, index: IndexSpec): string;
  dropIndexSql(definition: CollectionDefinition, indexName: string): string;
  qualifyTable(collectionName: string): string;
}
//#endregion
//#region src/infrastructure/collections/CollectionRegistry.d.ts
declare class CollectionRegistry {
  private readonly definitions;
  constructor(appConfig: AppConfig);
  resolve(name: string): CollectionDefinition | undefined;
  list(): ReadonlyArray<CollectionDefinition>;
  has(name: string): boolean;
}
//#endregion
//#region src/infrastructure/collections/CollectionSchemaIntrospector.types.d.ts
interface CollectionSchemaIntrospector {
  introspect(): Promise<LiveCollectionsSchema>;
}
//#endregion
//#region src/infrastructure/collections/CollectionSchemaDiffer.d.ts
declare class CollectionSchemaDiffer {
  diff(declared: CollectionDefinition, live: LiveCollectionTable | undefined): DiffOps;
  private buildColumnsForCreate;
  private buildColumnSpec;
  private mapFieldType;
  private buildIndexSpec;
}
//#endregion
//#region src/infrastructure/collections/CollectionSchemaSyncer.d.ts
declare class CollectionSchemaSyncer {
  private readonly collectionRegistry;
  private readonly introspector;
  private readonly differ;
  private readonly ddlEmitter;
  private readonly lockService;
  private readonly prismaClient;
  private readonly logger;
  private readonly env;
  constructor(collectionRegistry: CollectionRegistry, introspector: CollectionSchemaIntrospector, differ: CollectionSchemaDiffer, ddlEmitter: CollectionDdlEmitter, lockService: CollectionAdvisoryLockService, prismaClient: PrismaDatabaseClient, logger: Logger, env: Readonly<NodeJS.ProcessEnv>);
  sync(opts?: {
    dryRun?: boolean;
  }): Promise<CollectionSyncResult>;
  private hasChanges;
  private applyOps;
}
//#endregion
//#region src/infrastructure/collections/CollectionSchemaSyncerHolder.d.ts
declare class CollectionSchemaSyncerHolder {
  private readonly syncer;
  constructor(syncer: CollectionSchemaSyncer | null);
  syncIfAvailable(opts?: {
    dryRun?: boolean;
  }): Promise<CollectionSyncResult | null>;
  hasSync(): boolean;
}
//#endregion
//#region src/domain/workflows/WorkflowActivationRepository.d.ts
type WorkflowActivationRow = Readonly<{
  workflowId: string;
  isActive: boolean;
}>;
interface WorkflowActivationRepository {
  loadAll(): Promise<ReadonlyArray<WorkflowActivationRow>>;
  upsert(workflowId: string, active: boolean): Promise<void>;
}
//#endregion
//#region src/infrastructure/persistence/RuntimeWorkflowActivationPolicy.d.ts
declare class RuntimeWorkflowActivationPolicy implements WorkflowActivationPolicy {
  private readonly activeByWorkflowId;
  hydrateFromRepository(repository: WorkflowActivationRepository): Promise<void>;
  set(workflowId: string, active: boolean): void;
  isActive(workflowId: WorkflowId): boolean;
}
//#endregion
//#region src/domain/runs/WorkflowRunRepository.d.ts
interface WorkflowRunRepository {
  load(runId: string): Promise<PersistedRunState | undefined>;
  loadRunDetail?(runId: string): Promise<WorkflowRunDetailDto | undefined>;
  save(state: PersistedRunState): Promise<void>;
  listRuns(args: Readonly<{
    workflowId?: string;
    limit?: number;
  }>): Promise<ReadonlyArray<RunSummary>>;
  listRunsOlderThan?(args: Readonly<{
    nowIso: string;
    defaultRetentionSeconds: number;
    limit?: number;
  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
  listBinaryStorageKeys?(runId: RunId): Promise<ReadonlyArray<string>>;
  deleteRun(runId: RunId): Promise<void>;
  updateTestCaseStatus?(runId: RunId, status: TestCaseRunStatus): Promise<void>;
}
//#endregion
//#region src/application/telemetry/OtelIdentityFactory.d.ts
declare class OtelIdentityFactory {
  createTraceId(runId: string): string;
  createRootSpanId(runId: string): string;
  createNodeSpanId(activationId: string): string;
  createConnectionInvocationSpanId(invocationId: string): string;
  createArtifactId(): string;
  createEphemeralSpanId(): string;
  private hashToHex;
  private ensureNonZeroHex;
}
//#endregion
//#region src/domain/workflows/WorkflowDefinitionRepository.d.ts
interface WorkflowDefinitionRepository {
  listDefinitions(): Promise<ReadonlyArray<WorkflowDefinition>>;
  getDefinition(workflowId: string): Promise<WorkflowDefinition | undefined>;
  resolveSnapshot(args: Readonly<{
    workflowId: string;
    workflowSnapshot?: unknown;
  }>): Promise<WorkflowDefinition | undefined>;
}
//#endregion
//#region src/application/telemetry/TelemetryEnricherChain.d.ts
interface TelemetryNodeMetadata {
  readonly workflowFolder?: string;
  readonly nodeType?: string;
  readonly nodeRole?: string;
}
declare class TelemetryEnricherChain {
  private readonly workflowDefinitionRepository;
  private readonly definitionsByWorkflowId;
  constructor(workflowDefinitionRepository: WorkflowDefinitionRepository);
  enrichNode(args: Readonly<{
    workflowId: string;
    nodeId: string;
  }>): Promise<TelemetryNodeMetadata>;
  enrichRun(workflowId: string): Promise<Readonly<{
    workflowFolder?: string;
  }>>;
  private loadDefinition;
  private toWorkflowFolder;
  private toNodeType;
  private toNodeRole;
}
//#endregion
//#region src/application/telemetry/TelemetryRetentionTimestampFactory.d.ts
declare class TelemetryRetentionTimestampFactory {
  static readonly defaultSpanRetentionSeconds: number;
  static readonly defaultArtifactRetentionSeconds: number;
  static readonly defaultMetricRetentionSeconds: number;
  createSpanExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string;
  createArtifactExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string;
  createMetricExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string;
  createTraceContextExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string;
  private createExpiry;
}
//#endregion
//#region src/application/telemetry/RunEventBusTelemetryReporter.d.ts
declare class RunEventBusTelemetryReporter {
  private readonly runEventBus;
  private readonly runTraceContextRepository;
  private readonly workflowRunRepository;
  private readonly telemetrySpanStore;
  private readonly telemetryEnricherChain;
  private readonly telemetryRetentionTimestampFactory;
  private readonly otelIdentityFactory;
  private subscription;
  constructor(runEventBus: RunEventBus, runTraceContextRepository: RunTraceContextRepository, workflowRunRepository: WorkflowRunRepository, telemetrySpanStore: TelemetrySpanStore, telemetryEnricherChain: TelemetryEnricherChain, telemetryRetentionTimestampFactory: TelemetryRetentionTimestampFactory, otelIdentityFactory: OtelIdentityFactory);
  start(): Promise<void>;
  stop(): Promise<void>;
  private handleEvent;
  private handleRunCreated;
  private handleRunSaved;
  private handleNodeSnapshot;
  private createNodeSpanUpsert;
  private loadPolicySnapshot;
}
//#endregion
//#region src/application/logging/LogFilter.d.ts
type LogFilter = (entry: Readonly<{
  scope: string;
  level: "info" | "warn" | "error" | "debug";
  message: string;
}>) => boolean;
//#endregion
//#region src/infrastructure/logging/ServerLoggerFactory.d.ts
declare class ServerLoggerFactory implements LoggerFactory {
  private readonly logLevelPolicyFactory;
  constructor(logLevelPolicyFactory: LogLevelPolicyFactory);
  create(scope: string): Logger;
  createFiltered(scope: string, filter: LogFilter): Logger;
  createPerformanceDiagnostics(scope: string): Logger;
}
//#endregion
//#region src/application/runs/WorkflowRunRetentionPruneScheduler.d.ts
declare class WorkflowRunRetentionPruneScheduler {
  private readonly clock;
  private readonly runs;
  private readonly binaryStorage;
  private readonly telemetrySpanStore;
  private readonly telemetryArtifactStore;
  private readonly telemetryMetricPointStore;
  private readonly appConfig;
  private static readonly defaultIntervalMs;
  private timer;
  private stopped;
  private inFlight;
  private readonly logger;
  constructor(clock: Clock, runs: WorkflowRunRepository, binaryStorage: BinaryStorage, telemetrySpanStore: TelemetrySpanStore, telemetryArtifactStore: TelemetryArtifactStore, telemetryMetricPointStore: TelemetryMetricPointStore, appConfig: AppConfig, loggerFactory: ServerLoggerFactory);
  start(): void;
  stop(): Promise<void>;
  runOnce(): Promise<void>;
  private scheduleTick;
  private runScheduledTick;
  private loadStorageKeysFromRunStateFallback;
  private collectStorageKeysFromValue;
}
//#endregion
//#region src/bootstrap/runtime/FrontendRuntime.d.ts
declare class FrontendRuntime {
  private readonly appConfig;
  private readonly databaseMigrations;
  private readonly runtimeWorkflowActivationPolicy;
  private readonly workflowActivationRepository;
  private readonly workflowRepository;
  private readonly runEventBusTelemetryReporter;
  private readonly workflowRunRetentionPruneScheduler;
  private readonly engine;
  private readonly collectionSchemaSyncerHolder;
  constructor(appConfig: AppConfig, databaseMigrations: DatabaseMigrations, runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy, workflowActivationRepository: WorkflowActivationRepository, workflowRepository: WorkflowRepository, runEventBusTelemetryReporter: RunEventBusTelemetryReporter, workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler, engine: Engine, collectionSchemaSyncerHolder: CollectionSchemaSyncerHolder);
  start(args?: Readonly<{
    skipPresentationServers?: boolean;
  }>): Promise<void>;
}
//#endregion
//#region src/infrastructure/scheduler/WorkerRuntimeScheduler.d.ts
type WorkerRuntimeHandle = Readonly<{
  stop: () => Promise<void>;
}>;
interface WorkerRuntimeScheduler extends NodeExecutionScheduler {
  createWorker(args: Readonly<{
    queues: ReadonlyArray<string>;
    requestHandler: NodeExecutionRequestHandler;
  }>): WorkerRuntimeHandle;
  close(): Promise<void>;
}
//#endregion
//#region src/bootstrap/runtime/WorkerRuntime.d.ts
declare class WorkerRuntime {
  private readonly appConfig;
  private readonly databaseMigrations;
  private readonly runtimeWorkflowActivationPolicy;
  private readonly workflowActivationRepository;
  private readonly workflowRepository;
  private readonly engine;
  private readonly runEventBusTelemetryReporter;
  private readonly workflowRunRetentionPruneScheduler;
  private readonly scheduler;
  private readonly lifecycle;
  private readonly collectionSchemaSyncerHolder;
  constructor(appConfig: AppConfig, databaseMigrations: DatabaseMigrations, runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy, workflowActivationRepository: WorkflowActivationRepository, workflowRepository: WorkflowRepository, engine: Engine, runEventBusTelemetryReporter: RunEventBusTelemetryReporter, workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler, scheduler: WorkerRuntimeScheduler, lifecycle: AppContainerLifecycle, collectionSchemaSyncerHolder: CollectionSchemaSyncerHolder);
  start(queues: ReadonlyArray<string>): Promise<WorkerRuntimeHandle>;
}
//#endregion
//#region src/application/auth/AuthenticatedPrincipal.d.ts
type AuthenticatedPrincipal = Readonly<{
  id: string;
  email: string | null;
  name: string | null;
  source?: "managed-jwt";
  workspaceId?: string;
}>;
//#endregion
//#region src/application/auth/SessionVerifier.d.ts
interface SessionVerifier {
  verify(request: Request): Promise<AuthenticatedPrincipal | null>;
}
//#endregion
//#region src/presentation/http/ServerHttpRouteParams.d.ts
type ServerHttpRouteParams = Readonly<Record<string, string>>;
//#endregion
//#region src/presentation/http/routeHandlers/BinaryHttpRouteHandlerFactory.d.ts
declare class BinaryHttpRouteHandler {
  private readonly queryBus;
  private readonly commandBus;
  private readonly binaryStorage;
  constructor(queryBus: QueryBus, commandBus: CommandBus, binaryStorage: BinaryStorage);
  getRunBinaryContent(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  getWorkflowOverlayBinaryContent(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  postWorkflowDebuggerOverlayBinaryUpload(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  private createBinaryResponse;
  private createContentDisposition;
  private escapeFilename;
}
//#endregion
//#region src/presentation/http/hono/HonoApiRouteRegistrar.d.ts
interface HonoApiRouteRegistrar {
  register(app: Hono): void;
}
//#endregion
//#region src/auth/managed/ManagedCorsMiddleware.d.ts
declare class ManagedCorsMiddleware {
  private readonly allowedOrigins;
  constructor(allowedOrigin: string);
  private isAllowed;
  handle(): MiddlewareHandler;
}
//#endregion
//#region src/presentation/http/hono/CodemationHonoApiAppFactory.d.ts
declare class CodemationHonoApiApp {
  private readonly app;
  constructor(sessionVerifier: SessionVerifier, registrars: ReadonlyArray<HonoApiRouteRegistrar>, binaryHttpRouteHandler: BinaryHttpRouteHandler, internalRegistrars: ReadonlyArray<InternalHonoApiRouteRegistrar>, corsMiddlewareList: ReadonlyArray<ManagedCorsMiddleware>);
  getHono(): Hono;
  fetch(request: Request): Response | Promise<Response>;
}
//#endregion
//#region src/workflows/BoundedDedupMap.d.ts
declare class BoundedDedupMap {
  private readonly capN;
  private readonly ttlMs;
  static readonly defaultCapN = 1000;
  static readonly defaultTtlMs = 60000;
  private readonly entries;
  constructor(capN?: number, ttlMs?: number);
  hasSeen(key: string): boolean;
  get size(): number;
}
//#endregion
//#region src/application/bus/CommandHandler.d.ts
declare abstract class CommandHandler<TCommand extends Command<TResult>, TResult> {
  abstract execute(command: TCommand): Promise<TResult>;
}
//#endregion
//#region src/application/bus/DomainEvent.d.ts
declare abstract class DomainEvent {}
//#endregion
//#region src/application/bus/DomainEventBus.d.ts
interface DomainEventBus {
  publish(event: DomainEvent): Promise<void>;
}
//#endregion
//#region src/application/bus/DomainEventHandler.d.ts
declare abstract class DomainEventHandler<TEvent extends DomainEvent> {
  abstract handle(event: TEvent): Promise<void>;
}
//#endregion
//#region src/application/bus/QueryHandler.d.ts
declare abstract class QueryHandler<TQuery extends Query<TResult>, TResult> {
  abstract execute(query: TQuery): Promise<TResult>;
}
//#endregion
//#region src/application/telemetry/TelemetrySpanPublisher.d.ts
interface TelemetrySpanPublisher {
  publishSpan(span: TelemetrySpanUpsert): Promise<void>;
}
//#endregion
//#region src/domain/workflows/WorkflowDebuggerOverlayState.d.ts
type WorkflowDebuggerOverlayState = Readonly<{
  workflowId: string;
  updatedAt: string;
  copiedFromRunId?: string;
  currentState: RunCurrentState;
}>;
//#endregion
//#region src/domain/workflows/WorkflowDebuggerOverlayRepository.d.ts
interface WorkflowDebuggerOverlayRepository {
  load(workflowId: string): Promise<WorkflowDebuggerOverlayState | undefined>;
  save(state: WorkflowDebuggerOverlayState): Promise<void>;
}
//#endregion
//#region src/audit/IAuditEmitter.d.ts
interface WorkflowAuditActor {
  readonly userId?: string;
  readonly sessionId?: string;
}
interface WorkflowAuditResource {
  readonly type: string;
  readonly id: string;
}
interface WorkflowAuditEntry {
  readonly id: string;
  readonly occurredAt: string;
  readonly actor: WorkflowAuditActor;
  readonly action: string;
  readonly resource: WorkflowAuditResource;
  readonly outcome: "success" | "failure";
  readonly errorCode?: string;
  readonly correlationId?: string;
  readonly workflowId: string;
  readonly runId?: string;
  readonly nodeId?: string;
}
interface IWorkflowAuditEmitter {
  emit(entry: WorkflowAuditEntry): Promise<void>;
}
//#endregion
//#region src/applicationTokens.d.ts
declare const ApplicationTokens: {
  readonly CodemationAuthConfig: TypeToken<CodemationAuthConfig | undefined>;
  readonly CodemationWhitelabelConfig: TypeToken<CodemationWhitelabelConfig>;
  readonly AppConfig: TypeToken<AppConfig>;
  readonly QueryBus: TypeToken<QueryBus>;
  readonly CommandBus: TypeToken<CommandBus>;
  readonly DomainEventBus: TypeToken<DomainEventBus>;
  readonly QueryHandler: TypeToken<QueryHandler<Query<unknown>, unknown>>;
  readonly CommandHandler: TypeToken<CommandHandler<Command<unknown>, unknown>>;
  readonly DomainEventHandler: TypeToken<DomainEventHandler<DomainEvent>>;
  readonly HonoApiRouteRegistrar: TypeToken<HonoApiRouteRegistrar>;
  readonly InternalHonoApiRouteRegistrar: TypeToken<InternalHonoApiRouteRegistrar>;
  readonly ManagedCorsMiddleware: TypeToken<ManagedCorsMiddleware>;
  readonly TelemetrySpanPublisher: TypeToken<TelemetrySpanPublisher>;
  readonly WorkerRuntimeScheduler: TypeToken<WorkerRuntimeScheduler>;
  readonly WorkflowDefinitionRepository: TypeToken<WorkflowDefinitionRepository>;
  readonly WorkflowActivationRepository: TypeToken<WorkflowActivationRepository>;
  readonly WorkflowDebuggerOverlayRepository: TypeToken<WorkflowDebuggerOverlayRepository>;
  readonly WorkflowRunRepository: TypeToken<WorkflowRunRepository>;
  readonly LoggerFactory: TypeToken<LoggerFactory>;
  readonly PerformanceDiagnosticsLogger: TypeToken<Logger>;
  readonly CredentialStore: TypeToken<CredentialStore>;
  readonly RunTraceContextRepository: TypeToken<RunTraceContextRepository>;
  readonly TelemetrySpanStore: TypeToken<TelemetrySpanStore>;
  readonly TelemetryArtifactStore: TypeToken<TelemetryArtifactStore>;
  readonly TelemetryMetricPointStore: TypeToken<TelemetryMetricPointStore>;
  readonly TelemetryExporter: TypeToken<TelemetryExporter>;
  readonly PrismaClient: TypeToken<PrismaDatabaseClient>;
  readonly SessionVerifier: TypeToken<SessionVerifier>;
  readonly Clock: TypeToken<Clock>;
  readonly WorkflowAuditEmitter: TypeToken<IWorkflowAuditEmitter>;
  readonly ProcessRunner: TypeToken<ProcessRunner>;
  readonly OAuthFlowExecutor: TypeToken<OAuthFlowExecutor>;
  readonly CredentialMaterialInnerProvider: TypeToken<CredentialMaterialProvider>;
  readonly TriggerDispatchDedupMap: TypeToken<BoundedDedupMap>;
};
//#endregion
//#region src/bootstrap/CodemationBootstrapRequest.d.ts
declare class CodemationBootstrapRequest {
  readonly consumerRoot: string;
  readonly repoRoot: string;
  readonly workflowSources: ReadonlyArray<string>;
  readonly env?: Readonly<NodeJS.ProcessEnv>;
  constructor(args: Readonly<{
    consumerRoot: string;
    repoRoot: string;
    workflowSources?: ReadonlyArray<string>;
    env?: Readonly<NodeJS.ProcessEnv>;
  }>);
  resolveEnvironment(): NodeJS.ProcessEnv;
}
//#endregion
//#region src/application/contracts/RunContracts.d.ts
type CreateRunRequest = Readonly<{
  workflowId?: string;
  items?: Items;
  synthesizeTriggerItems?: boolean;
  currentState?: RunCurrentState;
  startAt?: string;
  stopAt?: string;
  clearFromNodeId?: string;
  mode?: "manual" | "debug";
  sourceRunId?: string;
}>;
type RunCommandResult = Readonly<{
  runId: string;
  workflowId: string;
  startedAt?: string;
  status: string;
  state: PersistedRunState | null;
}>;
//#endregion
//#region src/presentation/config/CodemationPluginListMerger.d.ts
declare class CodemationPluginListMerger {
  private readonly packageMetadata;
  constructor(packageMetadata: CodemationPluginPackageMetadata);
  merge(configuredPlugins: ReadonlyArray<CodemationPlugin>, discoveredPlugins: ReadonlyArray<CodemationPlugin>): ReadonlyArray<CodemationPlugin>;
  private tryAdd;
}
//#endregion
export { Query as C, QueryBus as S, Command as T, WorkflowRunRepository as _, ApplicationTokens as a, AppContainerLifecycle as b, CodemationHonoApiApp as c, SessionVerifier as d, WorkerRuntime as f, LogFilter as g, ServerLoggerFactory as h, CodemationBootstrapRequest as i, BinaryHttpRouteHandler as l, WorkflowRunRetentionPruneScheduler as m, CreateRunRequest as n, WorkflowDebuggerOverlayRepository as o, FrontendRuntime as p, RunCommandResult as r, TelemetrySpanPublisher as s, CodemationPluginListMerger as t, ServerHttpRouteParams as u, CollectionSchemaSyncerHolder as v, CommandBus as w, AppContainerFactory as x, DatabaseMigrations as y };
//# sourceMappingURL=CodemationPluginListMerger-D8lTaghf.d.ts.map