import "../Operator"
import * as T from "../Effect"
import * as M from "../Managed"
import * as Q from "../Queue"
import * as PR from "./primitives"
export declare type HubDequeue<R, E, A> = Q.XQueue<never, R, unknown, E, never, A>
export declare type HubEnqueue<R, E, A> = Q.XQueue<R, never, E, unknown, A, never>
export declare type Hub<A> = XHub<unknown, unknown, never, never, A, A>
export declare const HubTypeId: unique symbol
/**
 * A `Hub<RA, RB, EA, EB, A, B>` is an asynchronous message hub. Publishers
 * can publish messages of type `A` to the hub and subscribers can subscribe to
 * take messages of type `B` from the hub. Publishing messages can require an
 * environment of type `RA` and fail with an error of type `EA`. Taking
 * messages can require an environment of type `RB` and fail with an error of
 * type `EB`.
 */
export interface XHub<RA, RB, EA, EB, A, B> {
  readonly typeId: typeof HubTypeId
  readonly [PR._RA]: (_: RA) => void
  readonly [PR._RB]: (_: RB) => void
  readonly [PR._EA]: () => EA
  readonly [PR._EB]: () => EB
  readonly [PR._A]: (_: A) => void
  readonly [PR._B]: () => B
}
export declare abstract class XHubInternal<RA, RB, EA, EB, A, B>
  implements XHub<RA, RB, EA, EB, A, B>
{
  readonly typeId: typeof HubTypeId;
  readonly [PR._RA]: (_: RA) => void;
  readonly [PR._RB]: (_: RB) => void;
  readonly [PR._EA]: () => EA;
  readonly [PR._EB]: () => EB;
  readonly [PR._A]: (_: A) => void;
  readonly [PR._B]: () => B
  /**
   * Waits for the hub to be shut down.
   */
  abstract awaitShutdown: T.UIO<void>
  /**
   * The maximum capacity of the hub.
   */
  abstract capacity: number
  /**
   * Checks whether the hub is shut down.
   */
  abstract isShutdown: T.UIO<boolean>
  /**
   * Publishes a message to the hub, returning whether the message was
   * published to the hub.
   */
  abstract publish(a: A): T.Effect<RA, EA, boolean>
  /**
   * Publishes all of the specified messages to the hub, returning whether
   * they were published to the hub.
   */
  abstract publishAll(as: Iterable<A>): T.Effect<RA, EA, boolean>
  /**
   * Shuts down the hub.
   */
  abstract shutdown: T.UIO<void>
  /**
   * The current number of messages in the hub.
   */
  abstract size: T.UIO<number>
  /**
   * Subscribes to receive messages from the hub. The resulting subscription
   * can be evaluated multiple times within the scope of the managed to take a
   * message from the hub each time.
   */
  abstract subscribe: M.Managed<unknown, never, HubDequeue<RB, EB, B>>
}
/**
 * @optimize remove
 */
export declare function concrete<RA, RB, EA, EB, A, B>(
  _: XHub<RA, RB, EA, EB, A, B>
): asserts _ is XHubInternal<RA, RB, EA, EB, A, B>
/**
 * Waits for the hub to be shut down.
 */
export declare function awaitShutdown<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): T.UIO<void>
/**
 * The maximum capacity of the hub.
 */
export declare function capacity<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): number
/**
 * Checks whether the hub is shut down.
 */
export declare function isShutdown<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): T.UIO<boolean>
/**
 * Publishes a message to the hub, returning whether the message was
 * published to the hub.
 */
export declare function publish_<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  a: A
): T.Effect<RA, EA, boolean>
/**
 * Publishes a message to the hub, returning whether the message was
 * published to the hub.
 *
 * @dataFirst publish_
 */
export declare function publish<A>(
  a: A
): <RA, RB, EA, EB, B>(self: XHub<RA, RB, EA, EB, A, B>) => T.Effect<RA, EA, boolean>
/**
 * Publishes all of the specified messages to the hub, returning whether
 * they were published to the hub.
 */
export declare function publishAll_<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  as: Iterable<A>
): T.Effect<RA, EA, boolean>
/**
 * Publishes all of the specified messages to the hub, returning whether
 * they were published to the hub.
 *
 * @dataFirst publishAll_
 */
export declare function publishAll<A>(
  as: Iterable<A>
): <RA, RB, EA, EB, B>(self: XHub<RA, RB, EA, EB, A, B>) => T.Effect<RA, EA, boolean>
/**
 * Shuts down the hub.
 */
export declare function shutdown<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): T.UIO<void>
/**
 * The current number of messages in the hub.
 */
export declare function size<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): T.UIO<number>
/**
 * Subscribes to receive messages from the hub. The resulting subscription
 * can be evaluated multiple times within the scope of the managed to take a
 * message from the hub each time.
 */
export declare function subscribe<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): M.Managed<unknown, never, HubDequeue<RB, EB, B>>
/**
 * Transforms messages published to the hub using the specified effectual
 * function.
 */
export declare function contramapM_<RA, RB, RC, EA, EB, EC, A, B, C>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (c: C) => T.Effect<RC, EC, A>
): XHub<RC & RA, RB, EA | EC, EB, C, B>
/**
 * Transforms messages published to the hub using the specified effectual
 * function.
 *
 * @dataFirst contramapM_
 */
export declare function contramapM<RC, EC, A, C>(
  f: (c: C) => T.Effect<RC, EC, A>
): <RA, RB, EA, EB, B>(
  self: XHub<RA, RB, EA, EB, A, B>
) => XHub<RC & RA, RB, EC | EA, EB, C, B>
/**
 * Transforms messages published to and taken from the hub using the
 * specified functions.
 */
export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (c: C) => A,
  g: (b: B) => D
): XHub<RA, RB, EA, EB, C, D>
/**
 * Transforms messages published to and taken from the hub using the
 * specified functions.
 *
 * @dataFirst dimap_
 */
export declare function dimap<A, B, C, D>(
  f: (c: C) => A,
  g: (b: B) => D
): <RA, RB, EA, EB>(self: XHub<RA, RB, EA, EB, A, B>) => XHub<RA, RB, EA, EB, C, D>
/**
 * Transforms messages published to and taken from the hub using the
 * specified effectual functions.
 */
export declare function dimapM_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (c: C) => T.Effect<RC, EC, A>,
  g: (b: B) => T.Effect<RD, ED, D>
): XHub<RC & RA, RD & RB, EA | EC, EB | ED, C, D>
/**
 * Transforms messages published to and taken from the hub using the
 * specified effectual functions.
 *
 * @dataFirst dimapM_
 */
export declare function dimapM<A, B, C, D, EC, ED, RC, RD>(
  f: (c: C) => T.Effect<RC, EC, A>,
  g: (b: B) => T.Effect<RD, ED, D>
): <RA, RB, EA, EB>(
  self: XHub<RA, RB, EA, EB, A, B>
) => XHub<RC & RA, RD & RB, EC | EA, ED | EB, C, D>
/**
 * Filters messages published to the hub using the specified function.
 */
export declare function filterInput_<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (a: A) => boolean
): XHub<RA, RB, EA, EB, A, B>
/**
 * Filters messages published to the hub using the specified function.
 *
 * @dataFirst filterInput_
 */
export declare function filterInput<A>(
  f: (a: A) => boolean
): <RA, RB, EA, EB, B>(self: XHub<RA, RB, EA, EB, A, B>) => XHub<RA, RB, EA, EB, A, B>
/**
 * Filters messages published to the hub using the specified effectual
 * function.
 */
export declare function filterInputM_<RA, RA1, RB, EA, EA1, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (a: A) => T.Effect<RA1, EA1, boolean>
): XHub<RA & RA1, RB, EA | EA1, EB, A, B>
/**
 * Filters messages published to the hub using the specified effectual
 * function.
 *
 * @dataFirst filterInputM_
 */
export declare function filterInputM<RA1, EA1, A>(
  f: (a: A) => T.Effect<RA1, EA1, boolean>
): <RA, RB, EA, EB, B>(
  self: XHub<RA, RB, EA, EB, A, B>
) => XHub<RA & RA1, RB, EA1 | EA, EB, A, B>
/**
 * Filters messages taken from the hub using the specified function.
 */
export declare function filterOutput_<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (b: B) => boolean
): XHub<RA, RB, EA, EB, A, B>
/**
 * Filters messages taken from the hub using the specified function.
 *
 * @dataFirst filterOutput_
 */
export declare function filterOutput<B>(
  f: (b: B) => boolean
): <RA, RB, EA, EB, A>(self: XHub<RA, RB, EA, EB, A, B>) => XHub<RA, RB, EA, EB, A, B>
/**
 * Filters messages taken from the hub using the specified effectual
 * function.
 */
export declare function filterOutputM_<RA, RB, RB1, EA, EB, EB1, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (a: B) => T.Effect<RB1, EB1, boolean>
): XHub<RA, RB & RB1, EA, EB | EB1, A, B>
/**
 * Filters messages taken from the hub using the specified effectual
 * function.
 *
 * @dataFirst filterOutputM_
 */
export declare function filterOutputM<RB1, EB1, B>(
  f: (a: B) => T.Effect<RB1, EB1, boolean>
): <RA, RB, EA, EB, A>(
  self: XHub<RA, RB, EA, EB, A, B>
) => XHub<RA, RB & RB1, EA, EB1 | EB, A, B>
/**
 * Transforms messages taken from the hub using the specified function.
 */
export declare function map_<RA, RB, EA, EB, A, B, C>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (b: B) => C
): XHub<RA, RB, EA, EB, A, C>
/**
 * Transforms messages taken from the hub using the specified function.
 *
 * @dataFirst map_
 */
export declare function map<B, C>(
  f: (b: B) => C
): <RA, RB, EA, EB, A>(self: XHub<RA, RB, EA, EB, A, B>) => XHub<RA, RB, EA, EB, A, C>
/**
 * Transforms messages taken from the hub using the specified effectual
 * function.
 */
export declare function mapM_<RA, RB, RC, EA, EB, EC, A, B, C>(
  self: XHub<RA, RB, EA, EB, A, B>,
  f: (b: B) => T.Effect<RC, EC, C>
): XHub<RA, RC & RB, EA, EB | EC, A, C>
/**
 * Transforms messages taken from the hub using the specified effectual
 * function.
 *
 * @dataFirst mapM_
 */
export declare function mapM<B, C, EC, RC>(
  f: (b: B) => T.Effect<RC, EC, C>
): <A, EA, EB, RA, RB>(
  self: XHub<RA, RB, EA, EB, A, B>
) => XHub<RA, RC & RB, EA, EC | EB, A, C>
/**
 * Views the hub as a queue that can only be written to.
 */
export declare function toQueue<RA, RB, EA, EB, A, B>(
  self: XHub<RA, RB, EA, EB, A, B>
): HubEnqueue<RA, EA, A>
/**
 * Creates a bounded hub with the back pressure strategy. The hub will retain
 * messages until they have been taken by all subscribers, applying back
 * pressure to publishers if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function makeBounded<A>(requestedCapacity: number): T.UIO<Hub<A>>
/**
 * Creates a bounded hub with the back pressure strategy. The hub will retain
 * messages until they have been taken by all subscribers, applying back
 * pressure to publishers if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function unsafeMakeBounded<A>(requestedCapacity: number): Hub<A>
/**
 * Creates a bounded hub with the dropping strategy. The hub will drop new
 * messages if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function makeDropping<A>(requestedCapacity: number): T.UIO<Hub<A>>
/**
 * Creates a bounded hub with the dropping strategy. The hub will drop new
 * messages if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function unsafeMakeDropping<A>(requestedCapacity: number): Hub<A>
/**
 * Creates a bounded hub with the sliding strategy. The hub will add new
 * messages and drop old messages if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function makeSliding<A>(requestedCapacity: number): T.UIO<Hub<A>>
/**
 * Creates a bounded hub with the sliding strategy. The hub will add new
 * messages and drop old messages if the hub is at capacity.
 *
 * For best performance use capacities that are powers of two.
 */
export declare function unsafeMakeSliding<A>(requestedCapacity: number): Hub<A>
/**
 * Creates an unbounded hub.
 */
export declare function makeUnbounded<A>(): T.UIO<Hub<A>>
/**
 * Creates an unbounded hub.
 */
export declare function unsafeMakeUnbounded<A>(): Hub<A>
//# sourceMappingURL=core.d.ts.map
