export declare const append: {
  <R1, E1>(
    route: Route<E1, R1>
  ): <E, R>(self: MessageRouter<E, R>) => MessageRouter<E1 | E, R | MessageRouter.ExcludeProvided<R1>>
  <E, R, E1, R1>(
    self: MessageRouter<E, R>,
    route: Route<E1, R1>
  ): MessageRouter<E | E1, R | MessageRouter.ExcludeProvided<R1>>
}

export declare const catchAll: {
  <E, E2, R2>(
    f: (e: E) => Route.Handler<E2, R2>
  ): <R>(self: MessageRouter<E, R>) => MessageRouter<E2, R | MessageRouter.ExcludeProvided<R2>>
  <E, R, E2, R2>(
    self: MessageRouter<E, R>,
    f: (e: E) => Route.Handler<E2, R2>
  ): MessageRouter<E2, R | MessageRouter.ExcludeProvided<R2>>
}

export declare const catchAllCause: {
  <E, E2, R2>(
    f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
  ): <R>(self: MessageRouter<E, R>) => MessageRouter<E2, R | MessageRouter.ExcludeProvided<R2>>
  <E, R, E2, R2>(
    self: MessageRouter<E, R>,
    f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
  ): MessageRouter<E2, R | MessageRouter.ExcludeProvided<R2>>
}

export declare const catchTag: {
  <K extends E extends { _tag: string } ? E["_tag"] : never, E, E1, R1>(
    k: K,
    f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
  ): <R>(
    self: MessageRouter<E, R>
  ) => MessageRouter<E1 | Exclude<E, { _tag: K }>, R | MessageRouter.ExcludeProvided<R1>>
  <E, R, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
    self: MessageRouter<E, R>,
    k: K,
    f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
  ): MessageRouter<E1 | Exclude<E, { _tag: K }>, R | MessageRouter.ExcludeProvided<R1>>
}

export declare const catchTags: {
  <
    E,
    Cases extends E extends { _tag: string }
      ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Route.Handler<any, any>) | undefined }
      : {}
  >(
    cases: Cases
  ): <R>(
    self: MessageRouter<E, R>
  ) => MessageRouter<
    | Exclude<E, { _tag: keyof Cases }>
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
      }[keyof Cases],
    | R
    | MessageRouter.ExcludeProvided<
        {
          [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
        }[keyof Cases]
      >
  >
  <
    R,
    E,
    Cases extends E extends { _tag: string }
      ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Route.Handler<any, any>) | undefined }
      : {}
  >(
    self: MessageRouter<E, R>,
    cases: Cases
  ): MessageRouter<
    | Exclude<E, { _tag: keyof Cases }>
    | {
        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
      }[keyof Cases],
    | R
    | MessageRouter.ExcludeProvided<
        {
          [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
        }[keyof Cases]
      >
  >
}

export declare const concat: {
  <R1, E1>(that: MessageRouter<E1, R1>): <E, R>(self: MessageRouter<E, R>) => MessageRouter<E1 | E, R1 | R>
  <E, R, R1, E1>(self: MessageRouter<E, R>, that: MessageRouter<E1, R1>): MessageRouter<E | E1, R | R1>
}

export declare const concatAll: <Routers extends ReadonlyArray<MessageRouter<unknown, unknown>>>(
  ...routers: Routers
) => [Routers[number]] extends [MessageRouter<infer E, infer R>] ? MessageRouter<E, R> : never

export declare const provideService: {
  <T extends Context.Tag<any, any>>(
    tag: T,
    service: Context.Tag.Service<T>
  ): <E, R>(self: MessageRouter<E, R>) => MessageRouter<E, Exclude<R, Context.Tag.Identifier<T>>>
  <E, R, T extends Context.Tag<any, any>>(
    self: MessageRouter<E, R>,
    tag: T,
    service: Context.Tag.Service<T>
  ): MessageRouter<E, Exclude<R, Context.Tag.Identifier<T>>>
}

export declare const provideServiceEffect: {
  <T extends Context.Tag<any, any>, R1, E1>(
    tag: T,
    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
  ): <E, R>(
    self: MessageRouter<E, R>
  ) => MessageRouter<
    E1 | E,
    Exclude<R, Context.Tag.Identifier<T>> | Exclude<MessageRouter.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
  >
  <E, R, T extends Context.Tag<any, any>, R1, E1>(
    self: MessageRouter<E, R>,
    tag: T,
    effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
  ): MessageRouter<
    E | E1,
    Exclude<R, Context.Tag.Identifier<T>> | Exclude<MessageRouter.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
  >
}

export declare const transform: {
  <E, R, R1, E1>(
    f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
  ): (self: MessageRouter<E, R>) => MessageRouter<E1, MessageRouter.ExcludeProvided<R1>>
  <E, R, R1, E1>(
    self: MessageRouter<E, R>,
    f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
  ): MessageRouter<E1, MessageRouter.ExcludeProvided<R1>>
}

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 interface MessageRouter<E = never, R = never> extends App.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 class Default

export declare const Tag: <const Name extends string>(
  id: Name
) => <Self, R = never, E = unknown>() => MessageRouter.TagClass<Self, Name, E, R>

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> = App.Default<E, R>

export type Path = string | RegExp