import { AnyProcedure, Context as Context$1, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler, AnyORPCError } from '@orpc/server';
import { Context, Effect } from 'effect';

interface WithEffectContext<Services> {
    /**
     * A pre-built Effect context providing the services available within this oRPC context.
     * Automatically provided to any effect that runs under this context.
     *
     * @example
     * ```ts
     * import { Context } from 'effect'
     *
     * interface ServerContext extends WithEffectContext<Random | Logger> {}
     *
     * const context: ServerContext = {
     *   'effect/context': Context.empty().pipe(
     *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
     *   ),
     * }
     * ```
     */
    ['effect/context']: Context.Context<Services>;
    /**
     * An optional hook to wrap any effect before it is executed within this oRPC context.
     * Useful for adding observability, tracing, or error handling.
     *
     * @example
     * ```ts
     * import { Resource, Tracer } from '@effect/opentelemetry'
     * import { Context, Effect, Layer } from 'effect'
     *
     * interface ServerContext extends WithEffectContext<never> {}
     *
     * const TracingLive = Tracer.layerGlobal.pipe(
     *   Layer.provide(Resource.layerFromEnv()),
     * )
     *
     * const context: ServerContext = {
     *   'effect/context': Context.empty(),
     *   'effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
     * }
     * ```
     */
    ['effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
        path: string[];
        procedure: AnyProcedure;
        signal?: undefined | AbortSignal;
    }) => Effect.Effect<A, E>;
}

type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
interface HandlerGen<TCurrentContext extends Context$1, TInput, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Generator<TYield, TReturn, never>;
}
declare function handlerGen<TCurrentContext extends Context$1, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn | Extract<InferYieldError<TYield>, AnyORPCError>, TErrorConstructorMap>;

export { handlerGen as h };
export type { HandlerGen as H, InferYieldError as I, WithEffectContext as W };