//#region src/shims/disposer.d.ts
interface AsyncDisposer extends AsyncDisposable {
  /**
   * Registers a cleanup callback. Callbacks run in reverse registration order (LIFO) when the
   * disposer is disposed.
   */
  defer(fn: () => void | PromiseLike<void>): void;
  /**
   * Tracks a disposable resource and returns it.
   */
  use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
  /**
   * Runs all registered teardown in reverse registration order. Equivalent to leaving an `await
   * using` scope.
   */
  dispose(): Promise<void>;
}
//#endregion
//#region src/lib/orchestration/task-graph.d.ts
type TaskRecord = Record<string, any>;
type TaskValidation<T extends TaskRecord> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? T[K] : never; };
type TaskResult<T> = T extends ((...args: any[]) => infer R) ? Awaited<R> : never;
type InferredTaskContext<T extends TaskRecord> = {
  $result: { readonly [K in keyof T]: ReturnType<T[K]> extends Promise<infer R> ? Promise<R> : Promise<ReturnType<T[K]>>; };
  $signal: AbortSignal;
  $disposer: AsyncDisposer;
  $race<V>(promise: PromiseLike<V>): Promise<V>;
};
type AllValue<T extends TaskRecord> = { [K in keyof T]: TaskResult<T[K]>; };
interface AllCatchContext<T extends TaskRecord> {
  failedTask: (keyof T & string) | undefined;
  partial: Partial<AllValue<T>>;
  signal: AbortSignal;
}
type AllCatchFn<T extends TaskRecord, C> = (error: unknown, ctx: AllCatchContext<T>) => C | Promise<C>;
interface AllOptions<T extends TaskRecord, C> {
  catch: AllCatchFn<T, C>;
}
interface SettledFulfilled<T> {
  status: "fulfilled";
  value: T;
}
interface SettledRejected {
  status: "rejected";
  reason: unknown;
}
type SettledResult<T> = SettledFulfilled<T> | SettledRejected;
type AllSettledResult<T extends TaskRecord> = { [K in keyof T]: SettledResult<TaskResult<T[K]>>; };
//#endregion
//#region src/lib/orchestration/flow.d.ts
declare const FLOW_EXIT_BRAND: unique symbol;
type FlowExit<T> = {
  readonly [FLOW_EXIT_BRAND]: T;
};
type ExitValue<T> = T extends FlowExit<infer V> ? V : never;
type FlowExitValue<T extends TaskRecord> = { [K in keyof T]: ExitValue<TaskResult<T[K]>>; }[keyof T];
type InferredFlowTaskContext<T extends TaskRecord> = InferredTaskContext<T> & {
  $exit<V>(value: V): FlowExit<V>;
};
type FlowResult<T extends TaskRecord> = FlowExitValue<T>;
//#endregion
export { AllSettledResult as a, SettledRejected as c, TaskResult as d, TaskValidation as f, AllOptions as i, SettledResult as l, FlowResult as n, InferredTaskContext as o, AsyncDisposer as p, InferredFlowTaskContext as r, SettledFulfilled as s, FlowExit as t, TaskRecord as u };
//# sourceMappingURL=flow-BxKpmKTg.d.ts.map