//#region src/parameter/Fetcher.d.ts
interface NextCallback {
  (error?: Error, value?: PipeResult): void;
  disable: () => void;
}
interface NextCallbacks {
  wrappers: NextCallback[];
  holding: boolean;
  held: {
    error?: Error;
    value?: PipeResult;
  }[];
  onConsumed?: () => void;
  onError?: (err: Error) => boolean;
  pipeIndex?: number;
}
declare class Fetcher {
  private keys;
  private _fetch;
  private raw;
  hasNext: boolean;
  constructor(parameter: PipeParameter | undefined, flag?: string);
  fetch(container: PipeResult, args?: PipeResult[], functions?: FunctionContainer, nextCallbacks?: NextCallbacks): PipeOutput;
  private lookup;
  private value;
  hasUnresolved(container: PipeResult, functions?: FunctionContainer): boolean;
  fetchNothing(_container: PipeResult, args: PipeResult[], _functions?: FunctionContainer, _nextCallbacks?: NextCallbacks): PipeOutput;
  fetchSingle(container: PipeResult, _args: PipeResult[], functions?: FunctionContainer, _nextCallbacks?: NextCallbacks): PipeOutput;
  fetchAsArray(container: PipeResult, _args: PipeResult[], functions?: FunctionContainer, nextCallbacks?: NextCallbacks): PipeOutput;
  fetchAsObject(container: PipeResult, _args: PipeResult[], functions?: FunctionContainer, nextCallbacks?: NextCallbacks): PipeOutput;
}
//#endregion
//#region src/parameter/Producer.d.ts
interface ResultOutput {
  output: PipeOutput;
  terminal: boolean;
}
declare class Producer {
  private keys;
  private _produce;
  private inputMode;
  private form;
  private resultName?;
  constructor(parameter: PipeParameter | undefined, flag?: string);
  produce(result: PipeResult, errorPath?: boolean): PipeOutput;
  get isResult(): boolean;
  produceResult(result: PipeResult): ResultOutput;
  expectValue(): void;
  private specLabel;
  produceOutput(result: PipeResult, errorPath?: boolean): PipeOutput;
  produceSingle(result: PipeResult): PipeOutput;
  produceFromArray(result: PipeResult): PipeOutput;
  produceFromObject(result: PipeResult): PipeOutput;
  private inputSource;
}
//#endregion
//#region src/pipeline/Pipe.d.ts
interface Pipe$1 {
  fn?: PipeFunction | null;
  not?: boolean;
  fnName: string;
  optional?: boolean;
  fetcher: Fetcher;
  producer: Producer;
  injected: boolean;
}
interface InputPipe {
  fnName: string;
  producer: Producer;
}
type PipeDefinition = [PipeFunction, PipeParameter?, PipeParameter?];
//#endregion
//#region src/common.d.ts
declare class NextCalledTwiceError extends Error {
  constructor();
}
declare class OutputNameError extends Error {
  constructor(message: string);
}
declare class OutputKeyError extends Error {
  constructor(message: string);
}
declare class AmbiguousContinuationError extends Error {
  constructor(message: string);
}
declare class PipelineAbortedError extends Error {
  readonly reason: unknown;
  constructor(reason?: unknown);
}
interface AbortSignalLike {
  readonly aborted: boolean;
  readonly reason?: unknown;
  addEventListener(type: string, listener: () => void): void;
  removeEventListener(type: string, listener: () => void): void;
}
interface AsyncPipelineRunner {
  (...args: unknown[]): Promise<PipeOutput>;
  withSignal(signal: AbortSignalLike, ...args: unknown[]): Promise<PipeOutput>;
}
type AnyFunction = (...args: never[]) => unknown;
type PipeResult = unknown;
type PipeOutput = PipeResult | PipeResult[] | {
  [key: string]: PipeResult;
};
type ResultValue<T> = {
  value: T;
  reason?: never;
};
type ResultReason<R> = {
  reason: R;
  value?: never;
};
type Result<T, R> = ResultValue<T> | ResultReason<R>;
type PipelineExitVia = 'value' | 'reason' | 'halt' | 'error' | 'abort';
interface PipelineExit {
  via: PipelineExitVia;
  step: number | null;
  name: string | null;
  reason?: PipeResult;
  error: unknown;
}
type ExitHandler = (exit: PipelineExit, container: ResultContainer) => void;
type ReasonHandler = (reason: PipeResult, exit: PipelineExit, container: ResultContainer) => void;
interface ResultContainer {
  [key: string]: PipeResult;
}
type PipeFunction = string | AnyFunction | Function;
type PipeName = string;
type PipeRename = `${string}:${string}`;
type PipeParameter = PipeName | PipeRename | string[];
interface FunctionContainer {
  [key: string]: unknown;
}
interface PipelineBase {
  readonly name: string;
  readonly pipes: Pipe$1[];
  readonly inputPipes?: InputPipe[];
  readonly functions: FunctionContainer;
  readonly errorHandler?: AnyFunction;
  readonly exitHandlers?: ExitHandler[];
  readonly reasonHandler?: ReasonHandler;
}
//#endregion
//#region src/typed.d.ts
interface TypedState {
  deps: object;
  args: readonly unknown[];
  ctx: object;
  gates: object;
  skipped: string;
  late: string;
  stopped: boolean;
  async: boolean;
  started: boolean;
  handled: boolean;
  observed: boolean;
}
interface TypedError<Message extends string> {
  readonly problem: Message;
}
type Empty = Record<never, never>;
type Flat<T> = { [K in keyof T]: T[K]; };
type Merge<A, B> = Flat<Omit<A, keyof B> & B>;
type Keys<T> = keyof T & string;
type Either<A extends boolean, B extends boolean> = A extends true ? true : B;
type IsAny<T> = 0 extends 1 & T ? true : false;
type IsAsync<R> = IsAny<R> extends true ? false : [Extract<R, PromiseLike<unknown>>] extends [never] ? false : true;
type RequiredKeys<V> = { [K in keyof V]-?: Record<never, never> extends Pick<V, K> ? never : K; }[keyof V];
type IsOpen<D> = string extends Keys<D> ? true : false;
type ReservedOutput<S extends TypedState> = 'next' | (IsOpen<S['deps']> extends true ? never : Keys<S['deps']>);
type Checked<Problem, Ok> = [Problem] extends [never] ? Ok : TypedError<Problem & string>;
type TypedNext = (error?: unknown, value?: unknown) => void;
type KnownName<S extends TypedState> = Keys<S['ctx']> | Keys<S['deps']>;
type InputName<S extends TypedState> = KnownName<S> | 'next';
type InputValue<S extends TypedState, K> = K extends 'next' ? TypedNext : K extends Keys<S['ctx']> ? S['ctx'][K] | (K extends S['skipped'] ? undefined : never) : K extends Keys<S['deps']> ? S['deps'][K] : never;
type InputSpec<S extends TypedState> = InputName<S> | readonly InputName<S>[] | null | undefined;
type InputTuple<S extends TypedState, K> = K extends readonly string[] ? [...{ [I in keyof K]: InputValue<S, K[I]>; }] : K extends string ? [InputValue<S, K>] : [...S['args']];
type UsesNext<K> = K extends readonly string[] ? 'next' extends K[number] ? true : false : K extends 'next' ? true : false;
type Produced<K, R> = UsesNext<K> extends true ? unknown : R;
type OutputSpec = string | readonly string[] | undefined;
type ValueArm<R> = Extract<R, {
  value: unknown;
}>['value'];
type ReasonArm<R> = Extract<R, {
  reason: unknown;
}>['reason'];
type Positional<O extends readonly string[], V extends readonly unknown[]> = { [I in keyof O as I extends `${number}` ? O[I] extends string ? O[I] : never : never]: I extends keyof V ? V[I] : V[number]; };
type FitsTuple<O extends readonly string[], V extends readonly unknown[]> = number extends V['length'] ? true : O['length'] extends Partial<V>['length'] ? true : false;
type BuiltIn = Date | RegExp | Error | Promise<unknown> | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer;
type AllMethods<V> = [Keys<V>] extends [never] ? true : V[Keys<V>] extends AnyCallable ? true : false;
type IsPlainObject<V> = V extends AnyCallable ? false : V extends readonly unknown[] ? false : V extends BuiltIn ? false : V extends object ? AllMethods<V> extends true ? false : true : false;
type IsEmptyArray<K> = K extends readonly [] ? true : false;
type Picked<O extends readonly string[], V> = { [K in O[number]]: K extends keyof V ? V[K] : never; };
type Destructured<O extends readonly string[], V> = V extends readonly unknown[] ? Positional<O, V> : Picked<O, V>;
type Bound<O, R> = O extends `result:${infer N}` ? { [P in N]: ValueArm<Awaited<R>>; } : O extends '{...}' ? Awaited<R> : O extends readonly string[] ? Destructured<O, Awaited<R>> : O extends string ? { [P in O]: Awaited<R>; } : Empty;
type GateBindings<S extends TypedState, O, R> = O extends `result:${infer N}` ? Merge<S['gates'], { [P in N]: (N extends Keys<S['gates']> ? S['gates'][N] : never) | ReasonArm<Awaited<R>>; }> : S['gates'];
type IsGate<O> = O extends `result:${string}` ? true : false;
interface Change {
  add: unknown;
  optional: boolean;
  stop: boolean;
  async: boolean;
  gates: object;
  start: boolean;
}
type Bind<S extends TypedState, C extends Change> = {
  deps: S['deps'];
  args: S['args'];
  ctx: Merge<S['ctx'], C['add']>;
  gates: C['gates'];
  skipped: Exclude<S['skipped'], Keys<C['add']>> | (C['optional'] extends true ? Keys<C['add']> : never);
  late: S['late'] | (S['stopped'] extends true ? Keys<C['add']> : never);
  stopped: Either<S['stopped'], C['stop']>;
  async: Either<S['async'], C['async']>;
  started: Either<S['started'], C['start']>;
  handled: S['handled'];
  observed: S['observed'];
};
type SetFlag<S extends TypedState, F extends 'handled' | 'observed'> = Flat<Omit<S, F> & { [P in F]: true; }>;
type GateNeedsResult = 'A "result:<name>" output requires the pipe to return { value } | { reason }';
type SpreadNeedsObject = 'A "{...}" output requires the pipe to return a plain object';
type NotTypedYet = 'Brace picks and src:dst renames are not typed yet; use an array output or a single name';
type ReservedName = 'This output name is reserved or shadows a configured dependency';
type DestructureMismatch = 'An array output requires the pipe to return an array or an object with every named key';
type DestructureTooLong = 'An array output names more positions than the returned tuple has';
type EmptyNames = 'An input, output, or end spec cannot be an empty array';
type EmptyName = 'A name cannot be an empty string';
type BraceInArray = 'A brace spec is not allowed inside an array';
type MalformedResultName = 'A "result:<name>" output needs a non-empty name without ":"';
type HandlerNotCallable = 'This error handler dependency is not a function';
type InterceptedName = 'The names "input" and "error" are dispatched to .input() and .error() by the runtime; rename the dependency';
type OptionalKey = 'An array output names an optional property; the runtime throws when it is absent';
type OutputProblem<S extends TypedState, O, R> = O extends undefined ? never : O extends '' ? EmptyName : O extends `result:${infer N}` ? N extends '' | `${string}:${string}` ? MalformedResultName : N extends ReservedOutput<S> ? ReservedName : IsAny<Awaited<R>> extends true ? never : Awaited<R> extends Result<unknown, unknown> ? never : GateNeedsResult : O extends '{...}' ? IsAny<Awaited<R>> extends true ? never : IsPlainObject<Awaited<R>> extends true ? [Keys<Awaited<R>> & ReservedOutput<S>] extends [never] ? never : ReservedName : SpreadNeedsObject : O extends `{${string}}` | `${string}:${string}` ? NotTypedYet : O extends readonly string[] ? IsEmptyArray<O> extends true ? EmptyNames : '' extends O[number] ? EmptyName : [Extract<O[number], `{${string}}`>] extends [never] ? [Extract<O[number], `${string}:${string}`>] extends [never] ? [O[number] & ReservedOutput<S>] extends [never] ? IsAny<Awaited<R>> extends true ? never : Awaited<R> extends readonly unknown[] ? FitsTuple<O, Awaited<R>> extends true ? never : DestructureTooLong : O[number] extends keyof Awaited<R> ? O[number] extends RequiredKeys<Awaited<R>> ? never : OptionalKey : DestructureMismatch : ReservedName : NotTypedYet : BraceInArray : O extends ReservedOutput<S> ? ReservedName : never;
type AfterFunctionPipe<S extends TypedState, K, O, R> = Bind<S, {
  add: Bound<O, Produced<K, R>>;
  optional: false;
  stop: IsGate<O>;
  async: Either<IsAsync<R>, UsesNext<K>>;
  gates: GateBindings<S, O, Produced<K, R>>;
  start: true;
}>;
type Sigils<N> = N extends `!${infer Rest}` ? Rest extends `?${infer Base}` ? {
  base: Base;
  not: true;
  optional: true;
} : {
  base: Rest;
  not: true;
  optional: false;
} : N extends `?${infer Base}` ? {
  base: Base;
  not: false;
  optional: true;
} : {
  base: N;
  not: false;
  optional: false;
};
type InjectedSpec<S extends TypedState> = KnownName<S> | `!${KnownName<S>}` | `?${string}` | `!?${string}`;
type Resolved<S extends TypedState, N> = InputValue<S, Sigils<N>['base']>;
type AnyCallable = (...args: never[]) => unknown;
type Callable<F> = [F] extends [never] ? (...args: unknown[]) => unknown : F extends AnyCallable ? F : never;
type IsFlowControl<F, Not extends boolean> = Not extends true ? true : [F] extends [never] ? false : [F] extends [boolean] ? true : false;
type InjectedReturn<S extends TypedState, N> = ReturnType<Callable<Resolved<S, N>>>;
type InjectedResult<S extends TypedState, N, K> = Produced<K, InjectedReturn<S, N>>;
type InjectedInputMismatch = 'The declared inputs do not match the parameters of the injected function';
type InjectedNotCallable = 'This dependency is neither a function nor a boolean';
type InjectedKindProblem<S extends TypedState, N> = N extends 'input' | 'error' ? InterceptedName : [Resolved<S, N>] extends [never] ? never : [Resolved<S, N>] extends [boolean] ? never : Resolved<S, N> extends AnyCallable ? never : InjectedNotCallable;
type EmptyNamesProblem<K> = IsEmptyArray<K> extends true ? EmptyNames : never;
type AmbiguousContinuation = 'A pipe that declares "next" must not return a thenable; use one continuation channel';
type ContinuationProblem<K, R> = UsesNext<K> extends true ? (IsAsync<R> extends true ? AmbiguousContinuation : never) : never;
type InjectedInputProblem<S extends TypedState, N, K> = IsFlowControl<Resolved<S, N>, Sigils<N>['not']> extends true ? never : [InputTuple<S, K>] extends [Parameters<Callable<Resolved<S, N>>>] ? never : InjectedInputMismatch;
type AfterInjectedPipe<S extends TypedState, N, K, O> = IsFlowControl<Resolved<S, N>, Sigils<N>['not']> extends true ? Bind<S, {
  add: Empty;
  optional: false;
  stop: true;
  async: IsAsync<InjectedReturn<S, N>>;
  gates: S['gates'];
  start: true;
}> : Bind<S, {
  add: Bound<O, InjectedResult<S, N, K>>;
  optional: Sigils<N>['optional'];
  stop: IsGate<O>;
  async: Either<IsAsync<InjectedReturn<S, N>>, UsesNext<K>>;
  gates: GateBindings<S, O, InjectedResult<S, N, K>>;
  start: true;
}>;
type ArgAt<Args extends readonly unknown[], I> = I extends keyof Args ? Args[I] : number extends Args['length'] ? Args[number] | undefined : undefined;
type InputBindings<S extends TypedState, K> = K extends readonly string[] ? { [I in keyof K as I extends `${number}` ? (K[I] extends string ? K[I] : never) : never]: ArgAt<S['args'], I>; } : K extends string ? { [P in K]: ArgAt<S['args'], '0'>; } : Empty;
type InputNamesProblem<K> = K extends '' ? EmptyName : K extends `{${string}}` ? NotTypedYet : K extends 'next' ? ReservedName : K extends readonly string[] ? IsEmptyArray<K> extends true ? EmptyNames : '' extends K[number] ? EmptyName : [Extract<K[number], `{${string}}`>] extends [never] ? 'next' extends K[number] ? ReservedName : never : BraceInArray : never;
type AfterInput<S extends TypedState, K> = Bind<S, {
  add: InputBindings<S, K>;
  optional: false;
  stop: false;
  async: false;
  gates: S['gates'];
  start: false;
}>;
type ErrorInputName<S extends TypedState> = 'error' | KnownName<S>;
type ErrorValue<S extends TypedState, K> = K extends 'error' ? unknown : K extends Keys<S['ctx']> ? S['ctx'][K] | undefined : K extends Keys<S['deps']> ? S['deps'][K] : never;
type ErrorTuple<S extends TypedState, K> = K extends readonly string[] ? [...{ [I in keyof K]: ErrorValue<S, K[I]>; }] : K extends string ? [ErrorValue<S, K>] : [unknown];
type Reasons<S extends TypedState> = S['gates'][Keys<S['gates']>];
type EndSpec<S extends TypedState> = KnownName<S> | readonly KnownName<S>[];
type EndSingle<S extends TypedState, N> = N extends Keys<S['ctx']> ? S['ctx'][N] | (N extends Keys<S['gates']> ? S['gates'][N] : never) | (N extends S['skipped'] | S['late'] ? undefined : never) : N extends Keys<S['deps']> ? S['deps'][N] : never;
type EndValue<S extends TypedState, O> = O extends readonly string[] ? [...{ [I in keyof O]: EndSingle<S, O[I]>; }] : EndSingle<S, O>;
type SyncRunner<S extends TypedState, Out> = (...args: [...S['args']]) => Out;
type SyncEndUnavailable = 'This pipeline has an async pipe; use endAsync()';
interface SyncEnd<S extends TypedState> {
  (): SyncRunner<S, undefined>;
  <const O extends EndSpec<S>>(output: O): Checked<EmptyNamesProblem<O>, SyncRunner<S, EndValue<S, O>>>;
}
interface SyncEndWhenAsync<S extends TypedState> {
  (): SyncRunner<S, undefined>;
  (output: SyncEndUnavailable): never;
}
interface TypedAsyncRunner<Args extends readonly unknown[], Out> {
  (...args: [...Args]): Promise<Out>;
  withSignal(signal: AbortSignalLike, ...args: [...Args]): Promise<Out>;
}
type InputAfterPipe = 'An input pipe must come before the first pipe';
type PipeAfterError = 'Adding a pipe after the error handler is not allowed';
type SecondErrorHandler = 'Each pipeline can have only one error handler';
type SecondReasonHandler = 'Each pipeline can have only one reason handler';
type InputMethod<S extends TypedState> = <const K extends string | readonly string[]>(names: K) => Checked<InputNamesProblem<K>, TypedPipeline<AfterInput<S, K>>>;
interface PipeMethod<S extends TypedState> {
  <const N extends InjectedSpec<S>, const K extends InputSpec<S> = undefined, const O extends OutputSpec = undefined>(name: N, input?: K, output?: O): Checked<InjectedKindProblem<S, N> | EmptyNamesProblem<K> | ContinuationProblem<K, InjectedReturn<S, N>> | InjectedInputProblem<S, N, K> | OutputProblem<S, O, InjectedResult<S, N, K>>, TypedPipeline<AfterInjectedPipe<S, N, K, O>>>;
  <R, const K extends InputSpec<S> = undefined, const O extends OutputSpec = undefined>(fn: (...args: InputTuple<S, K>) => R, input?: K, output?: O): Checked<EmptyNamesProblem<K> | ContinuationProblem<K, R> | OutputProblem<S, O, Produced<K, R>>, TypedPipeline<AfterFunctionPipe<S, K, O, R>>>;
}
type ErrorHandlerProblem<S extends TypedState, H, K> = H extends string ? InputValue<S, H> extends AnyCallable ? [ErrorTuple<S, K>] extends [Parameters<InputValue<S, H>>] ? never : InjectedInputMismatch : HandlerNotCallable : never;
type ErrorMethod<S extends TypedState> = <H extends ((...args: ErrorTuple<S, K>) => unknown) | KnownName<S>, const K extends ErrorInputName<S> | readonly ErrorInputName<S>[] = 'error'>(handler: H, input?: K) => Checked<EmptyNamesProblem<K> | ErrorHandlerProblem<S, H, K>, TypedPipeline<SetFlag<S, 'handled'>>>;
type ReasonMethod<S extends TypedState> = (handler: (reason: Reasons<S>, exit: PipelineExit, container: ResultContainer) => unknown) => TypedPipeline<SetFlag<S, 'observed'>>;
interface TypedPipeline<S extends TypedState> {
  readonly input: S['started'] extends true ? (names: InputAfterPipe) => never : InputMethod<S>;
  readonly pipe: S['handled'] extends true ? (fn: PipeAfterError) => never : PipeMethod<S>;
  readonly error: S['handled'] extends true ? (handler: SecondErrorHandler) => never : ErrorMethod<S>;
  readonly reason: S['observed'] extends true ? (handler: SecondReasonHandler) => never : ReasonMethod<S>;
  onExit(handler: ExitHandler): TypedPipeline<S>;
  readonly end: S['async'] extends true ? SyncEndWhenAsync<S> : SyncEnd<S>;
  endAsync(): TypedAsyncRunner<S['args'], undefined>;
  endAsync<const O extends EndSpec<S>>(output: O): Checked<EmptyNamesProblem<O>, TypedAsyncRunner<S['args'], EndValue<S, O>>>;
}
type InitialState<D extends object, Args extends readonly unknown[]> = {
  deps: D;
  args: Args;
  ctx: Empty;
  gates: Empty;
  skipped: never;
  late: never;
  stopped: false;
  async: false;
  started: false;
  handled: false;
  observed: false;
};
type TypedFactory<D extends object> = <Args extends readonly unknown[] = unknown[]>(name: string) => TypedPipeline<InitialState<D, Args>>;
declare function typed<D extends object = Empty>(deps?: D): TypedFactory<D>;
//#endregion
//#region src/index.d.ts
declare function superpipe<T extends FunctionContainer = FunctionContainer>(functions?: T): SuperPipeFactory;
interface Pipeline {
  name: string;
  pipes: Pipe[];
  errorHandler?: Pipe;
  deps: FunctionContainer;
}
interface Pipe {
  fn: ((...args: unknown[]) => unknown) | null;
  fnName: string | undefined;
  input: string[];
  output?: string[];
  not?: boolean;
  optional?: boolean;
}
interface PipelineAPI {
  input: (input?: PipeParameter) => PipelineAPI;
  pipe: (fn: PipeFunction, input?: PipeParameter, output?: PipeParameter) => PipelineAPI;
  error: (fn: PipeFunction, input?: PipeParameter) => PipelineAPI;
  onExit: (handler: ExitHandler) => PipelineAPI;
  reason: (handler: ReasonHandler) => PipelineAPI;
  end: (output?: PipeParameter) => Function;
  endAsync: (output?: PipeParameter) => AsyncPipelineRunner;
}
interface SuperPipeFactory {
  (name: string): PipelineAPI;
  (name: string, defs: PipeDefinition[]): (...args: unknown[]) => void;
  (name: string, defs?: PipeDefinition[]): PipelineAPI | ((...args: unknown[]) => void);
}
type Store = {
  next: (error?: unknown, value?: unknown) => void;
  error?: unknown;
  [key: string]: unknown;
};
interface PipeState {
  fn: ((...args: unknown[]) => unknown) | null;
  not?: boolean;
  deps: FunctionContainer;
  input: string[];
  output?: string[];
  fnName: string | undefined;
  autoNext: boolean | 0;
  optional?: boolean;
  name: string;
  error?: unknown;
  result?: unknown;
  fnReturned?: boolean;
}
//#endregion
export { type AbortSignalLike, AmbiguousContinuationError, type AnyFunction, type AsyncPipelineRunner, type FunctionContainer as Dependencies, type FunctionContainer, type ExitHandler, type InputSpec, NextCalledTwiceError, OutputKeyError, OutputNameError, type OutputSpec, Pipe, type PipeDefinition, type PipeDefinition as PipelineDefinition, type PipeFunction, type PipeName, type PipeOutput, type PipeParameter, type PipeRename, type PipeResult, PipeState, Pipeline, PipelineAPI, PipelineAbortedError, type PipelineBase, type PipelineExit, type PipelineExitVia, type ReasonHandler, type Result, type ResultContainer, type ResultReason, type ResultValue, Store, SuperPipeFactory, type TypedAsyncRunner, type TypedError, type TypedFactory, type TypedNext, type TypedPipeline, type TypedState, superpipe as default, typed };

//# sourceMappingURL=index.d.mts.map