export declare const empty: MessageRouter<never, never>

export declare const fromIterable: <R extends Route<any, any>>(
  routes: Iterable<R>
) => MessageRouter<R extends Route<infer E, infer _> ? E : never, R extends Route<infer _, infer Env> ? Env : never>

export declare const makeRoute: <E, R>(
  topic: Route.Path,
  handler: Route.Handler<E, R>
) => Route<E, MessageRouter.ExcludeProvided<R>>

export type Default<E = never, R = never> = Effect.Effect<void, E, R | ConsumerRecord.ConsumerRecord>

export interface MessageRouter<E = never, R = never> extends Default<E, R>, Inspectable.Inspectable {
  readonly [TypeId]: TypeId
  readonly routes: Chunk.Chunk<Route<E, R>>
}

export interface Route<E = never, R = never> {
  readonly [RouteTypeId]: RouteTypeId
  readonly topic: Route.Path
  readonly handler: Route.Handler<E, R>
}

export declare const subscribe: {
  <E1, R1>(
    topic: Route.Path,
    handler: Route.Handler<E1, R1>
  ): <E, R>(self: MessageRouter<E, R>) => MessageRouter<E1 | E, R | MessageRouter.ExcludeProvided<R1>>
  <E, R, E1, R1>(
    self: MessageRouter<E, R>,
    topic: Route.Path,
    handler: Route.Handler<E1, R1>
  ): MessageRouter<E | E1, R | MessageRouter.ExcludeProvided<R1>>
}

export declare const RouteTypeId: typeof RouteTypeId

export type RouteTypeId = typeof RouteTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

export interface Service<E, R> {
  readonly router: Effect.Effect<MessageRouter<E, R>>
  readonly addRoute: (route: Route<E, R>) => Effect.Effect<void>
  readonly subscribe: (path: Route.Path, handler: Route.Handler<E, R | Provided>) => Effect.Effect<void>
  readonly concat: (router: MessageRouter<E, R>) => Effect.Effect<void>
}

export interface TagClass<Self, Name extends string, E, R> extends Context.Tag<Self, Service<E, R>> {
  readonly Live: Layer.Layer<Self>
  readonly router: Effect.Effect<MessageRouter<E, R>, never, Self>
  // readonly use: <XA, XE, XR>(
  //   f: (router: Service<E, R>) => Effect.Effect<XA, XE, XR>,
  // ) => Layer.Layer<never, XE, XR>;
  // readonly useScoped: <XA, XE, XR>(
  //   f: (router: Service<E, R>) => Effect.Effect<XA, XE, XR>,
  // ) => Layer.Layer<never, XE, Exclude<XR, Scope.Scope>>;
  readonly unwrap: <XA, XE, XR>(f: (router: MessageRouter<E, R>) => Layer.Layer<XA, XE, XR>) => Layer.Layer<XA, XE, XR>
  new (_: never): Context.TagClassShape<Name, Service<E, R>>
}

export type ExcludeProvided<A> = Exclude<A, Provided>

export type Provided = ConsumerRecord.ConsumerRecord | Scope.Scope

export type Handler<E, R> = Default<E, R>

export type Path = string | RegExp