import { ServiceUpdate } from "./watch.mjs";
import { Operation, Stream, WithResolvers } from "effection";

//#region src/service-graph.d.ts
/**
 * Context key for the Simulacrum gateway listening port.
 *
 * When `useServiceGraph` starts the optional simulacrum gateway (via the
 * `globalData` option) it sets this context value to the listening port so
 * operations in the graph (including `useSimulation`) can discover and fetch the `/data` payload.
 */
declare const SimulacrumEndpoint: import("effection").Context<number>;
type ServiceDefinition<S, T = unknown> = {
  operation: Operation<T>;
  watch?: string[];
  watchDebounce?: number;
  dependsOn?: {
    startup: readonly S[];
    restart?: readonly S[];
  };
  options?: {};
};
type ServiceMap = Record<string, ServiceDefinition<string, any>>;
type ServiceGraph<S extends ServiceMap> = {
  services: S;
  serviceUpdates: Stream<ServiceUpdate, unknown> | undefined;
  serviceChanges: Stream<ServiceUpdate, unknown> | undefined;
  status: Map<string, ServiceStatus>;
};
type ServiceGraphStatus = {
  cwd: string;
  services: Record<string, ServiceInfo>;
};
type ServiceInfo = {
  port?: number | undefined;
  pid?: number | undefined;
};
type ServiceStatus = {
  startup: WithResolvers<void>;
  running: WithResolvers<void>;
  port?: number | undefined;
  pid?: number | undefined;
};
type ServiceGraphRunOptions = {
  watch?: boolean;
  watchDebounce?: number;
  controlPort?: number | undefined;
  exclude?: string[] | undefined;
  requestStop?: (() => void) | undefined;
  requestRestart?: ((service?: string) => void) | undefined;
};
type ServiceGraphRunner<S extends ServiceMap> = (subset?: Array<keyof S>, runOptions?: ServiceGraphRunOptions) => Operation<ServiceGraph<S>>;
type ServiceGraphFor<R extends ServiceGraphRunner<any>> = R extends ServiceGraphRunner<infer S> ? ServiceGraph<S> : never;
/**
 * Start a graph of services with dependency ordering and optional file
 * watching/restart behavior.
 *
 * Each service is defined as a `ServiceDefinition` that includes an
 * `operation: Operation<T>` which should return once the service is ready. The
 * returned runner function yields the graph resource directly for Effection
 * callers.
 *
 * @param services - a map of service names to definitions
 * @param options - optional configuration: `{ globalData?, watch?, watchDebounce? }`
 * @returns a runner function returning the graph operation
 */
declare function useServiceGraph<S extends ServiceMap>(services: S, options?: {
  globalData?: Record<string, unknown>;
  watch?: boolean;
  watchDebounce?: number;
  controlPort?: number;
}): ServiceGraphRunner<S>;
//#endregion
export { ServiceDefinition, ServiceGraph, ServiceGraphFor, ServiceGraphRunOptions, ServiceGraphRunner, ServiceGraphStatus, ServiceInfo, ServiceStatus, SimulacrumEndpoint, useServiceGraph };