import * as O from "../../Option";
import * as T from "./_internal/task";
import { XQueue } from "./model";
/**
 * Takes between min and max number of values from the queue. If there
 * is less than min items available, it'll block until the items are
 * collected.
 */
export declare const takeBetween: (
   min: number,
   max: number
) => <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RB, EB, readonly B[]>;
/**
 * Takes between min and max number of values from the queue. If there
 * is less than min items available, it'll block until the items are
 * collected.
 */
export declare const takeBetween_: <RA, RB, EA, EB, A, B>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   min: number,
   max: number
) => T.Task<RB, EB, readonly B[]>;
/**
 * Waits until the queue is shutdown.
 * The `IO` returned by this method will not resume until the queue has been shutdown.
 * If the queue is already shutdown, the `IO` will resume right away.
 */
export declare const awaitShutdown: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.IO<void>;
/**
 * How many elements can hold in the queue
 */
export declare const capacity: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => number;
/**
 * `true` if `shutdown` has been called.
 */
export declare const isShutdown: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.IO<boolean>;
/**
 * Places one value in the queue.
 */
export declare const offer: <A>(
   a: A
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RA, EA, boolean>;
/**
 * Places one value in the queue.
 */
export declare const offer_: <RA, RB, EA, EB, A, B>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   a: A
) => T.Task<RA, EA, boolean>;
/**
 * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
 * If the queue has reached capacity, then
 * the fiber performing the `offerAll` will be suspended until there is room in
 * the queue.
 *
 * For Unbounded Queue:
 * Places all values in the queue and returns true.
 *
 * For Sliding Queue: uses `Sliding` Strategy
 * If there is room in the queue, it places the values otherwise it removes the old elements and
 * enqueues the new ones. Always returns true.
 *
 * For Dropping Queue: uses `Dropping` Strategy,
 * It places the values in the queue but if there is no room it will not enqueue them and return false.
 *
 */
export declare const offerAll: <A>(
   as: Iterable<A>
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RA, EA, boolean>;
/**
 * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
 * If the queue has reached capacity, then
 * the fiber performing the `offerAll` will be suspended until there is room in
 * the queue.
 *
 * For Unbounded Queue:
 * Places all values in the queue and returns true.
 *
 * For Sliding Queue: uses `Sliding` Strategy
 * If there is room in the queue, it places the values otherwise it removes the old elements and
 * enqueues the new ones. Always returns true.
 *
 * For Dropping Queue: uses `Dropping` Strategy,
 * It places the values in the queue but if there is no room it will not enqueue them and return false.
 *
 */
export declare const offerAll_: <RA, RB, EA, EB, A, B>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   as: Iterable<A>
) => T.Task<RA, EA, boolean>;
/**
 * Interrupts any fibers that are suspended on `offer` or `take`.
 * Future calls to `offer*` and `take*` will be interrupted immediately.
 */
export declare const shutdown: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.IO<void>;
/**
 * Retrieves the size of the queue, which is equal to the number of elements
 * in the queue. This may be negative if fibers are suspended waiting for
 * elements to be added to the queue.
 */
export declare const size: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.IO<number>;
/**
 * Removes the oldest value in the queue. If the queue is empty, this will
 * return a computation that resumes when an item has been added to the queue.
 */
export declare const take: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RB, EB, B>;
/**
 * Removes all the values in the queue and returns the list of the values. If the queue
 * is empty returns empty list.
 */
export declare const takeAll: <RA, RB, EA, EB, A, B>(
   self: XQueue<RA, RB, EA, EB, A, B>
) => T.Task<RB, EB, readonly B[]>;
/**
 * Takes up to max number of values in the queue.
 */
export declare const takeAllUpTo: (
   n: number
) => <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RB, EB, readonly B[]>;
/**
 * Takes up to max number of values in the queue.
 */
export declare const takeAllUpTo_: <RA, RB, EA, EB, A, B>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   n: number
) => T.Task<RB, EB, readonly B[]>;
/**
 * Creates a new queue from this queue and another. Offering to the composite queue
 * will broadcast the elements to both queues; taking from the composite queue
 * will dequeue elements from both queues and apply the function point-wise.
 *
 * Note that using queues with different strategies may result in surprising behavior.
 * For example, a dropping queue and a bounded queue composed together may apply `f`
 * to different elements.
 */
export declare const mapBothM: <RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => T.Task<R3, E3, D>
) => <RA, RB, EA, EB>(
   self: XQueue<RA, RB, EA, EB, A, B>
) => XQueue<RA & RA1, RB & RB1 & R3, EA1 | EA, EB1 | E3 | EB, A1, D>;
/**
 * Creates a new queue from this queue and another. Offering to the composite queue
 * will broadcast the elements to both queues; taking from the composite queue
 * will dequeue elements from both queues and apply the function point-wise.
 *
 * Note that using queues with different strategies may result in surprising behavior.
 * For example, a dropping queue and a bounded queue composed together may apply `f`
 * to different elements.
 */
export declare const mapBothM_: <RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => T.Task<R3, E3, D>
) => XQueue<RA & RA1, RB & RB1 & R3, EA | EA1, EB | EB1 | E3, A1, D>;
/**
 * Like `bothWithM`, but uses a pure function.
 */
export declare const mapBoth: <RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => D
) => <RA, RB, EA, EB>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA & RA1, RB & RB1, EA1 | EA, EB1 | EB, A1, D>;
/**
 * Like `bothWithM`, but uses a pure function.
 */
export declare const mapBoth_: <RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>,
   f: (b: B, c: C) => D
) => XQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, D>;
/**
 * Like `bothWith`, but tuples the elements instead of applying a function.
 */
export declare const both: <RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>
) => <RA, RB, EA, EB>(
   self: XQueue<RA, RB, EA, EB, A, B>
) => XQueue<RA & RA1, RB & RB1, EA1 | EA, EB1 | EB, A1, readonly [B, C]>;
/**
 * Like `bothWith`, but tuples the elements instead of applying a function.
 */
export declare const both_: <RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   that: XQueue<RA1, RB1, EA1, EB1, A1, C>
) => XQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;
/**
 * Transforms elements enqueued into and dequeued from this queue with the
 * specified effectual functions.
 */
export declare const bimap: <A, B, C, D>(
   f: (c: C) => A,
   g: (b: B) => D
) => <RA, RB, EA, EB>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA, RB, EA, EB, C, D>;
/**
 * Transforms elements enqueued into and dequeued from this queue with the
 * specified effectual functions.
 */
export declare const bimap_: <RA, RB, EA, EB, A, B, C, D>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => A,
   g: (b: B) => D
) => XQueue<RA, RB, EA, EB, C, D>;
/**
 * Transforms elements enqueued into and dequeued from this queue with the
 * specified effectual functions.
 */
export declare const bimapM: <A, B, C, RC, EC, RD, ED, D>(
   f: (c: C) => T.Task<RC, EC, A>,
   g: (b: B) => T.Task<RD, ED, D>
) => <RA, RB, EA, EB>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RC & RA, RD & RB, EC | EA, ED | EB, C, D>;
/**
 * Transforms elements enqueued into and dequeued from this queue with the
 * specified effectual functions.
 */
export declare const bimapM_: <RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   f: (c: C) => T.Task<RC, EC, A>,
   g: (b: B) => T.Task<RD, ED, D>
) => XQueue<RC & RA, RD & RB, EA | EC, EB | ED, C, D>;
/**
 * Transforms elements enqueued into this queue with a taskful function.
 */
export declare const contramapM: <C, RA2, EA2, A>(
   f: (c: C) => T.Task<RA2, EA2, A>
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA2 & RA, RB, EA2 | EA, EB, C, B>;
/**
 * Transforms elements enqueued into this queue with a pure function.
 */
export declare const contramap: <C, A>(
   f: (c: C) => A
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA, RB, EA, EB, C, B>;
/**
 * Like `filterInput`, but uses a taskful function to filter the elements.
 */
export declare const filterInputM: <A, A1 extends A, R2, E2>(
   f: (_: A1) => T.Task<R2, E2, boolean>
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA & R2, RB, E2 | EA, EB, A1, B>;
/**
 * Like `filterInput`, but uses a taskful function to filter the elements.
 */
export declare const filterInputM_: <RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => T.Task<R2, E2, boolean>
) => XQueue<RA & R2, RB, EA | E2, EB, A1, B>;
/**
 * Applies a filter to elements enqueued into this queue. Elements that do not
 * pass the filter will be immediately dropped.
 */
export declare const filterInput: <A, A1 extends A>(
   f: (_: A1) => boolean
) => <RA, RB, EA, EB, B>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA, RB, EA, EB, A1, B>;
/**
 * Applies a filter to elements enqueued into this queue. Elements that do not
 * pass the filter will be immediately dropped.
 */
export declare const filterInput_: <RA, RB, EA, EB, B, A, A1 extends A>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   f: (_: A1) => boolean
) => XQueue<RA, RB, EA, EB, A1, B>;
/**
 * Transforms elements dequeued from this queue with a taskful function.
 */
export declare const mapM: <B, R2, E2, C>(
   f: (b: B) => T.Task<R2, E2, C>
) => <RA, RB, EA, EB, A>(self: XQueue<RA, RB, EA, EB, A, B>) => XQueue<RA, R2 & RB, EA, E2 | EB, A, C>;
/**
 * Transforms elements dequeued from this queue with a taskful function.
 */
export declare const mapM_: <RA, RB, EA, EB, A, B, R2, E2, C>(
   self: XQueue<RA, RB, EA, EB, A, B>,
   f: (b: B) => T.Task<R2, E2, C>
) => XQueue<RA, R2 & RB, EA, EB | E2, A, C>;
/**
 * Take the head option of values in the queue.
 */
export declare const poll: <RA, RB, EA, EB, A, B>(self: XQueue<RA, RB, EA, EB, A, B>) => T.Task<RB, EB, O.Option<B>>;
//# sourceMappingURL=combinators.d.ts.map