export declare const toHandler: <R extends Router<any, any>>(
  router: R,
  options?: { readonly spanPrefix?: string }
) => (u: unknown) => Stream.Stream<Router.Response, ParseError, Router.Context<R>>

export declare const toHandlerEffect: <R extends Router<any, any>>(
  router: R,
  options?: { readonly spanPrefix?: string }
) => (u: unknown) => Effect.Effect<readonly any[], ParseError, Router.Context<R>>

export declare const toHandlerRaw: <R extends Router<any, any>>(
  router: R
) => <Req extends Router.Request<R>>(request: Req) => Stream.Stream<A, E, R>

export declare const toHandlerUndecoded: <R extends Router<any, any>>(
  router: R
) => <Req extends Router.Request<R>>(request: Req) => Rpc.Rpc.ResultUndecoded<Req, Router.Context<R>>

export declare const make: <Rpcs extends readonly (Rpc.Rpc<any, any> | Router<any, any>)[]>(
  ...rpcs: Rpcs
) => Router<
  any,
  | Rpc.Rpc.Context<Extract<Rpcs[number], { readonly [Rpc.TypeId]: Rpc.TypeId }>>
  | Router.Context<Extract<Rpcs[number], { readonly [TypeId]: TypeId }>>
>

export declare const provideService: {
  <I, S>(
    tag: Context.Tag<I, S>,
    service: S
  ): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, Exclude<R, I>>
  <Reqs extends Schema.TaggedRequest.Any, R, I, S>(
    self: Router<Reqs, R>,
    tag: Context.Tag<I, S>,
    service: S
  ): Router<Reqs, Exclude<R, I>>
}

export declare const provideServiceEffect: {
  <I, S, E, R2>(
    tag: Context.Tag<I, S>,
    effect: Effect.Effect<S, E, R2>
  ): <Reqs extends Schema.TaggedRequest.Any, R>(self: Router<Reqs, R>) => Router<Reqs, R2 | Exclude<R, I>>
  <Reqs extends Schema.TaggedRequest.Any, R, I, S, E, R2>(
    self: Router<Reqs, R>,
    tag: Context.Tag<I, S>,
    effect: Effect.Effect<S, E, R2>
  ): Router<Reqs, R2 | Exclude<R, I>>
}

export interface Router<Reqs extends Schema.TaggedRequest.Any, R> extends Pipeable {
  readonly [TypeId]: TypeId
  readonly rpcs: ReadonlySet<Rpc.Rpc<Reqs, R>>
}

export type Context<A extends Router<any, any>> =
  A extends Router<infer Req, infer R> ? R | Serializable.SerializableWithResult.Context<Req> : never

export type ContextRaw<A extends Router<any, any>> =
  A extends Router<infer Req, infer R> ? R | Serializable.Serializable.Context<Req> : never

export type Request<A extends Router<any, any>> = A extends Router<infer Req, infer _R> ? Req : never

export type Response = [
  index: number,
  response: Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>
]

export type ResponseEffect = Schema.ExitEncoded<any, any> | ReadonlyArray<Schema.ExitEncoded<any, any>>

export declare const isRouter: (u: unknown) => u is Router<any, any>

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId