import { n as OAuthFlowExecutor, r as RunIntentService } from "./index-Cy08dvyb.js";
import { $ as RunEventBus, Dt as WebhookInvocationMatch, P as WorkflowDefinition, Q as RunEvent, b as BinaryAttachment, j as RunIdFactory, o as BinaryStorage, ot as WorkflowActivationPolicy, x as Item, y as ActivationIdFactory } from "./ItemsInputNormalizer-C2gLv7d9.js";
import { r as AppConfig } from "./CodemationAppContext-CA4xzGA6.js";
import { l as Logger, u as LoggerFactory } from "./CodemationWhitelabelConfig-CPKKZwGp.js";
import { n as logLevelPolicyFactory, t as LogLevelPolicyFactory } from "./LogLevelPolicyFactory-Cu5Ef_mL.js";
import { a as CodemationFrontendAuthSnapshot, i as CodemationFrontendAuthProviderSnapshot, n as InternalAuthBootstrap, r as FrontendAppConfig, t as PublicFrontendBootstrap } from "./PublicFrontendBootstrap-D6TF254t.js";
import "./CodemationConfigNormalizer-CvZ1Sb3a.js";
import { a as CredentialSecretCipher, i as CredentialInstanceService, o as McpServerCatalog, r as CredentialBindingService, t as CredentialStore } from "./CredentialServices-vjUDU7PW.js";
import "./CredentialContractsRegistry-BUODyn3G.js";
import { s as TelemetrySpanUpsert } from "./TelemetryContracts-CfeVZRFL.js";
import { i as WorkflowSummary, t as WorkflowDto } from "./WorkflowViewContracts-CpxVwR1E.js";
import { S as QueryBus, _ as WorkflowRunRepository, a as ApplicationTokens, b as AppContainerLifecycle, c as CodemationHonoApiApp, d as SessionVerifier, f as WorkerRuntime, g as LogFilter, h as ServerLoggerFactory, i as CodemationBootstrapRequest, l as BinaryHttpRouteHandler, m as WorkflowRunRetentionPruneScheduler, n as CreateRunRequest, o as WorkflowDebuggerOverlayRepository, p as FrontendRuntime, s as TelemetrySpanPublisher, t as CodemationPluginListMerger, u as ServerHttpRouteParams, w as CommandBus, x as AppContainerFactory, y as DatabaseMigrations } from "./CodemationPluginListMerger-D8lTaghf.js";
import { t as AppConfigFactory } from "./AppConfigFactory-DZjtXivd.js";
import "./PrismaMigrationDeployer-BoM4dvIC.js";
import "./InternalHonoApiRouteRegistrar-Ck5-r6yB.js";
import { n as InternalAuthBootstrapFactory, r as FrontendAppConfigFactory, t as PublicFrontendBootstrapFactory } from "./PublicFrontendBootstrapFactory-DDz0bVIV.js";
import { t as WorkflowPolicyUiPresentationFactory } from "./WorkflowPolicyUiPresentationFactory-CUHGlZ_p.js";
import { t as PairingConfig } from "./pairing.types-CtmKKNaP.js";

//#region src/application/dev/DevBootstrapSummaryJson.types.d.ts
type DevBootstrapSummaryJson = Readonly<{
  logLevel: string;
  codemationLogLevelEnv?: string;
  databaseLabel: string;
  schedulerLabel: string;
  eventBusLabel: string;
  redisUrlRedacted?: string;
  activeWorkflows: ReadonlyArray<Readonly<{
    id: string;
    name: string;
  }>>;
  plugins: ReadonlyArray<Readonly<{
    packageName: string;
    source: "configured" | "discovered";
  }>>;
}>;
//#endregion
//#region src/infrastructure/logging/FilteringLogger.d.ts
declare class FilteringLogger implements Logger {
  private readonly inner;
  private readonly scope;
  private readonly filter;
  constructor(inner: Logger, scope: string, filter: LogFilter);
  info(message: string, exception?: Error): void;
  warn(message: string, exception?: Error): void;
  error(message: string, exception?: Error): void;
  debug(message: string, exception?: Error): void;
}
//#endregion
//#region src/infrastructure/logging/PerformanceLogPolicy.d.ts
declare class PerformanceLogPolicy {
  shouldEmitDetailedTiming(): boolean;
}
//#endregion
//#region src/infrastructure/logging/PerformanceLogPolicyFactory.d.ts
declare class PerformanceLogPolicyFactory {
  private readonly policy;
  create(): PerformanceLogPolicy;
}
declare const performanceLogPolicyFactory: PerformanceLogPolicyFactory;
//#endregion
//#region src/application/binary/RunBinaryAttachmentLookupService.d.ts
declare class RunBinaryAttachmentLookupService {
  private readonly workflowRunRepository;
  private readonly workflowDebuggerOverlayRepository;
  constructor(workflowRunRepository: WorkflowRunRepository, workflowDebuggerOverlayRepository: WorkflowDebuggerOverlayRepository);
  findForRun(runId: string, binaryId: string): Promise<BinaryAttachment | undefined>;
  findForWorkflowOverlay(workflowId: string, binaryId: string): Promise<BinaryAttachment | undefined>;
  private findInRunState;
  private findInCurrentState;
  private findInOutputsByNode;
  private findInNodeSnapshots;
  private findInCurrentStateSnapshots;
  private findInMutableState;
  private findInPortItemMap;
  private findInItems;
}
//#endregion
//#region src/application/mapping/DataMapper.d.ts
interface DataMapper<TSource, TTarget> {
  map(source: TSource): Promise<TTarget>;
}
//#endregion
//#region src/application/mapping/WorkflowDefinitionMapper.d.ts
declare class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition, WorkflowDto> {
  private readonly policyUi;
  private readonly workflowActivationPolicy;
  private readonly mcpCatalog;
  constructor(policyUi: WorkflowPolicyUiPresentationFactory, workflowActivationPolicy: WorkflowActivationPolicy, mcpCatalog: McpServerCatalog);
  map(workflow: WorkflowDefinition): Promise<WorkflowDto>;
  mapSync(workflow: WorkflowDefinition): WorkflowDto;
  toSummary(workflow: WorkflowDefinition): WorkflowSummary;
  private buildConnectionChildMeta;
  private mapNodesAndEdges;
  private toNodes;
  private toEdges;
  private appendMaterializedConnectionEdges;
  private buildAgentConnectionDescriptorIndex;
  private appendVirtualConnectionNodes;
  private appendVirtualConnectionEdges;
  private edgeKey;
  private createConnectionNode;
  private readInspectorSummary;
  private nodePortFieldsFromConfig;
  private nodeTypeName;
}
//#endregion
//#region src/infrastructure/webhooks/RequestToWebhookItemMapper.d.ts
declare class RequestToWebhookItemMapper {
  private readonly binaryStorage;
  private readonly runIdFactory;
  private readonly activationIdFactory;
  constructor(binaryStorage: BinaryStorage, runIdFactory: RunIdFactory, activationIdFactory: ActivationIdFactory);
  map(request: Request, match: WebhookInvocationMatch): Promise<Item>;
  private mapMultipart;
  private parseJsonBody;
  private isJsonRequest;
  private resolveBody;
  private toHeaders;
  private toQuery;
}
//#endregion
//#region src/presentation/http/routeHandlers/CredentialHttpRouteHandler.d.ts
declare class CredentialHttpRouteHandler {
  private readonly queryBus;
  private readonly commandBus;
  private readonly sessionVerifier;
  private readonly pairingConfig;
  constructor(queryBus: QueryBus, commandBus: CommandBus, sessionVerifier: SessionVerifier, pairingConfig: PairingConfig | null);
  getCredentialTypes(): Promise<Response>;
  getCredentialFieldEnvStatus(): Promise<Response>;
  getCredentialInstances(): Promise<Response>;
  getCredentialApps(): Promise<Response>;
  getCredentialInstance(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  postCredentialInstance(request: Request): Promise<Response>;
  putCredentialInstance(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  deleteCredentialInstance(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  putCredentialBinding(request: Request): Promise<Response>;
  postCredentialInstanceTest(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  getWorkflowCredentialHealth(_: Request, params: ServerHttpRouteParams): Promise<Response>;
}
//#endregion
//#region src/domain/credentials/OAuth2RedirectUriResolver.d.ts
declare class OAuth2RedirectUriResolver {
  private readonly appConfig;
  constructor(appConfig: AppConfig);
  resolve(requestOrigin: string): string;
  private ensureAbsoluteUrl;
  private normalizeBaseUrl;
}
//#endregion
//#region src/presentation/http/routeHandlers/OAuth2HttpRouteHandlerFactory.d.ts
declare class OAuth2HttpRouteHandler {
  private readonly redirectUriResolver;
  private readonly credentialInstanceService;
  private readonly oauthFlowExecutor;
  private readonly credentialStore;
  private readonly credentialSecretCipher;
  constructor(redirectUriResolver: OAuth2RedirectUriResolver, credentialInstanceService: CredentialInstanceService, oauthFlowExecutor: OAuthFlowExecutor, credentialStore: CredentialStore, credentialSecretCipher: CredentialSecretCipher);
  getRedirectUri(request: Request): Promise<Response>;
  postDisconnect(request: Request): Promise<Response>;
  postOAuthStart(request: Request): Promise<Response>;
  getOAuthCallback(request: Request): Promise<Response>;
  private resolveRequestOrigin;
  private static firstCommaSeparatedValue;
  private createPopupHtml;
}
//#endregion
//#region src/application/telemetry/SseSpanSink.types.d.ts
interface SseSpanSink {
  send(span: TelemetrySpanUpsert): void;
}
//#endregion
//#region src/application/telemetry/TelemetrySpanSseFanout.d.ts
declare class TelemetrySpanSseFanout implements TelemetrySpanPublisher {
  private readonly sinks;
  register(runId: string, sink: SseSpanSink): void;
  unregister(runId: string, sink: SseSpanSink): void;
  publishSpan(span: TelemetrySpanUpsert): Promise<void>;
}
//#endregion
//#region src/presentation/http/sse/RunSseStreamHelper.d.ts
interface RunSseStreamOptions {
  belongsToStream: (e: RunEvent) => boolean;
  isTerminal: (e: RunEvent) => boolean;
  runId?: string;
  telemetryFanout?: TelemetrySpanSseFanout;
  heartbeatMs?: number;
}
interface SseStreamController {
  start(): Promise<void>;
  bind(preamble: unknown, options: RunSseStreamOptions): void;
  readonly stream: ReadableStream<Uint8Array>;
}
declare class RunSseStreamHelper {
  private readonly runEventBus;
  constructor(runEventBus: RunEventBus);
  createStream(): SseStreamController;
}
//#endregion
//#region src/presentation/http/routeHandlers/RunHttpRouteHandler.d.ts
declare class RunHttpRouteHandler {
  private readonly queryBus;
  private readonly commandBus;
  private readonly sseStreamHelper;
  private readonly telemetryFanout;
  constructor(queryBus: QueryBus, commandBus: CommandBus, sseStreamHelper: RunSseStreamHelper, telemetryFanout: TelemetrySpanSseFanout);
  private acceptsSse;
  private isRunTerminal;
  private streamRunResult;
  getRun(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  getRunDetail(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  runOrStream(body: CreateRunRequest, acceptsSse: boolean): Promise<Response>;
  postRuns(request: Request, _: ServerHttpRouteParams): Promise<Response>;
  patchRunWorkflowSnapshot(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  patchRunNodePin(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  postRunNode(request: Request, params: ServerHttpRouteParams): Promise<Response>;
}
//#endregion
//#region src/presentation/http/routeHandlers/WebhookHttpRouteHandler.d.ts
declare class WebhookHttpRouteHandler {
  private readonly commandBus;
  private readonly runIntentService;
  private readonly requestToWebhookItemMapper;
  constructor(commandBus: CommandBus, runIntentService: RunIntentService, requestToWebhookItemMapper: RequestToWebhookItemMapper);
  postWebhook(request: Request, params: ServerHttpRouteParams): Promise<Response>;
}
//#endregion
//#region src/presentation/http/routeHandlers/WorkflowHttpRouteHandler.d.ts
declare class WorkflowHttpRouteHandler {
  private readonly queryBus;
  private readonly commandBus;
  private readonly workflowDefinitionMapper;
  constructor(queryBus: QueryBus, commandBus: CommandBus, workflowDefinitionMapper: WorkflowDefinitionMapper);
  getWorkflows(_: Request, __: ServerHttpRouteParams): Promise<Response>;
  getWorkflow(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  patchWorkflowActivation(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  getWorkflowRuns(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  getWorkflowDebuggerOverlay(_: Request, params: ServerHttpRouteParams): Promise<Response>;
  putWorkflowDebuggerOverlay(request: Request, params: ServerHttpRouteParams): Promise<Response>;
  postCopyWorkflowDebuggerOverlay(request: Request, params: ServerHttpRouteParams): Promise<Response>;
}
//#endregion
export { AppConfigFactory, AppContainerFactory, AppContainerLifecycle, ApplicationTokens, BinaryHttpRouteHandler, CodemationBootstrapRequest, type CodemationFrontendAuthProviderSnapshot, type CodemationFrontendAuthSnapshot, CodemationHonoApiApp, CodemationPluginListMerger, CredentialBindingService, CredentialHttpRouteHandler, CredentialInstanceService, DatabaseMigrations, type DevBootstrapSummaryJson, FilteringLogger, type FrontendAppConfig, FrontendAppConfigFactory, FrontendRuntime, type InternalAuthBootstrap, InternalAuthBootstrapFactory, type LogFilter, LogLevelPolicyFactory, type Logger, type LoggerFactory, OAuth2HttpRouteHandler, PerformanceLogPolicy, PerformanceLogPolicyFactory, type PublicFrontendBootstrap, PublicFrontendBootstrapFactory, RequestToWebhookItemMapper, RunBinaryAttachmentLookupService, RunHttpRouteHandler, ServerLoggerFactory, WebhookHttpRouteHandler, WorkerRuntime, WorkflowDefinitionMapper, WorkflowHttpRouteHandler, WorkflowPolicyUiPresentationFactory, WorkflowRunRetentionPruneScheduler, logLevelPolicyFactory, performanceLogPolicyFactory };
//# sourceMappingURL=nextServer.d.ts.map