Sink

declare const collectAll: <In>() => Sink<Chunk.Chunk<In>, In>;

declare const collectAllN: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>;

declare const collectAllToMap: <In, K>(
  key: (input: In) => K,
  merge: (x: In, y: In) => In,
) => Sink<HashMap.HashMap<K, In>, In>;

declare const collectAllToMapN: <In, K>(
  n: number,
  key: (input: In) => K,
  merge: (x: In, y: In) => In,
) => Sink<HashMap.HashMap<K, In>, In, In>;

declare const collectAllToSet: <In>() => Sink<HashSet.HashSet<In>, In>;

declare const collectAllToSetN: <In>(n: number) => Sink<HashSet.HashSet<In>, In, In>;

declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<Chunk.Chunk<In>, In, In>;

declare const collectAllUntilEffect: <In, E, R>(
  p: (input: In) => Effect.Effect<boolean, E, R>,
) => Sink<Chunk.Chunk<In>, In, In, E, R>;

declare const collectAllWhile: {
  <In, Out>(refinement: Refinement<In, Out>): Sink<Chunk<Out>, In, In>;
  <In>(predicate: Predicate<In>): Sink<Chunk<In>, In, In>;
};

declare const collectAllWhileEffect: <In, E, R>(
  predicate: (input: In) => Effect.Effect<boolean, E, R>,
) => Sink<Chunk.Chunk<In>, In, In, E, R>;

declare const context: <R>() => Sink<Context.Context<R>, unknown, never, never, R>;

declare const contextWith: <R, Z>(
  f: (context: Context.Context<R>) => Z,
) => Sink<Z, unknown, never, never, R>;

declare const contextWithEffect: <R0, A, E, R>(
  f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>,
) => Sink<A, unknown, never, E, R0 | R>;

declare const contextWithSink: <R0, A, In, L, E, R>(
  f: (context: Context.Context<R0>) => Sink<A, In, L, E, R>,
) => Sink<A, In, L, E, R0 | R>;

declare const count: Sink<number, unknown>;

declare const die: (defect: unknown) => Sink<never, unknown>;

declare const dieMessage: (message: string) => Sink<never, unknown>;

declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, unknown>;

declare const drain: Sink<void, unknown>;

declare const drop: <In>(n: number) => Sink<unknown, In, In>;

declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>;

declare const dropUntilEffect: <In, E, R>(
  predicate: (input: In) => Effect.Effect<boolean, E, R>,
) => Sink<unknown, In, In, E, R>;

declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>;

declare const dropWhileEffect: <In, E, R>(
  predicate: (input: In) => Effect.Effect<boolean, E, R>,
) => Sink<unknown, In, In, E, R>;

declare const every: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>;

declare const fail: <E>(e: E) => Sink<never, unknown, never, E>;

declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, unknown, never, E>;

declare const failCauseSync: <E>(
  evaluate: LazyArg<Cause.Cause<E>>,
) => Sink<never, unknown, never, E>;

declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, unknown, never, E>;

declare const foldChunks: <S, In>(
  s: S,
  contFn: Predicate<S>,
  f: (s: S, chunk: Chunk.Chunk<In>) => S,
) => Sink<S, In>;

declare const foldChunksEffect: <S, In, E, R>(
  s: S,
  contFn: Predicate<S>,
  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>,
) => Sink<S, In, In, E, R>;

declare const foldEffect: <S, In, E, R>(
  s: S,
  contFn: Predicate<S>,
  f: (s: S, input: In) => Effect.Effect<S, E, R>,
) => Sink<S, In, In, E, R>;

declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<S, In>;

declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>;

declare const foldLeftChunksEffect: <S, In, E, R>(
  s: S,
  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>,
) => Sink<S, In, never, E, R>;

declare const foldLeftEffect: <S, In, E, R>(
  s: S,
  f: (s: S, input: In) => Effect.Effect<S, E, R>,
) => Sink<S, In, In, E, R>;

declare const foldUntil: <In, S>(s: S, max: number, f: (s: S, input: In) => S) => Sink<S, In, In>;

declare const foldUntilEffect: <S, In, E, R>(
  s: S,
  max: number,
  f: (s: S, input: In) => Effect.Effect<S, E, R>,
) => Sink<S, In, In, E, R>;

declare const foldWeighted: <S, In>(options: {
  readonly body: (s: S, input: In) => S;
  readonly cost: (s: S, input: In) => number;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In>;

declare const foldWeightedDecompose: <S, In>(options: {
  readonly body: (s: S, input: In) => S;
  readonly cost: (s: S, input: In) => number;
  readonly decompose: (input: In) => Chunk.Chunk<In>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In>;

declare const foldWeightedDecomposeEffect: <S, In, E, R, E2, R2, E3, R3>(options: {
  readonly body: (s: S, input: In) => Effect.Effect<S, E3, R3>;
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
  readonly decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In, E | E2 | E3, R | R2 | R3>;

declare const foldWeightedEffect: <S, In, E, R, E2, R2>(options: {
  readonly body: (s: S, input: In) => Effect.Effect<S, E2, R2>;
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In, E | E2, R | R2>;

declare const forEach: <In, X, E, R>(
  f: (input: In) => Effect.Effect<X, E, R>,
) => Sink<void, In, never, E, R>;

declare const forEachChunk: <In, X, E, R>(
  f: (input: Chunk.Chunk<In>) => Effect.Effect<X, E, R>,
) => Sink<void, In, never, E, R>;

declare const forEachChunkWhile: <In, E, R>(
  f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>,
) => Sink<void, In, In, E, R>;

declare const forEachWhile: <In, E, R>(
  f: (input: In) => Effect.Effect<boolean, E, R>,
) => Sink<void, In, In, E, R>;

declare const fromChannel: <L, In, E, A, R>(
  channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>,
) => Sink<A, In, L, E, R>;

declare const fromEffect: <A, E, R>(
  effect: Effect.Effect<A, E, R>,
) => Sink<A, unknown, never, E, R>;

declare const fromPubSub: <In>(
  pubsub: PubSub.PubSub<In>,
  options?: {
    readonly shutdown?: boolean;
  },
) => Sink<void, In>;

declare const fromPush: <In, L0, R0, L, R>(
  push: Effect.Effect<
    (
      _: Option.Option<Chunk.Chunk<In>>,
    ) => Effect.Effect<void, readonly [Either.Either<R0, L0>, Chunk.Chunk<L>], R>,
    never,
    R
  >,
) => Sink<R0, In, L, L0, Exclude<R, Scope.Scope>>;

declare const fromQueue: <In>(
  queue: Queue.Enqueue<In>,
  options?: {
    readonly shutdown?: boolean;
  },
) => Sink<void, In>;

declare const head: <In>() => Sink<Option.Option<In>, In, In>;

declare const last: <In>() => Sink<Option.Option<In>, In, In>;

declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<void, unknown, L>;

declare const mkString: Sink<string, unknown>;

declare const never: Sink<never, unknown>;

declare const some: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>;

declare const succeed: <A>(a: A) => Sink<A, unknown>;

declare const sum: Sink<number, number>;

declare const suspend: <A, In, L, E, R>(
  evaluate: LazyArg<Sink<A, In, L, E, R>>,
) => Sink<A, In, L, E, R>;

declare const sync: <A>(evaluate: LazyArg<A>) => Sink<A, unknown>;

declare const take: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>;

declare const timed: Sink<Duration.Duration, unknown>;

declare const toChannel: <A, In, L, E, R>(
  self: Sink<A, In, L, E, R>,
) => Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>;

declare const unwrap: <A, In, L, E2, R2, E, R>(
  effect: Effect.Effect<Sink<A, In, L, E2, R2>, E, R>,
) => Sink<A, In, L, E2 | E, R2 | R>;

declare const unwrapScoped: <A, In, L, E, R>(
  effect: Effect.Effect<Sink<A, In, L, E, R>, E, R>,
) => Sink<A, In, L, E, Exclude<R, Scope.Scope>>;

declare const unwrapScopedWith: <A, In, L, E, R>(
  f: (scope: Scope.Scope) => Effect.Effect<Sink<A, In, L, E, R>, E, R>,
) => Sink<A, In, L, E, R>;

declare const provideContext: {
  <R>(context: Context<R>): <A, In, L, E>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, never>;
  <A, In, L, E, R>(self: Sink<A, In, L, E, R>, context: Context<R>): Sink<A, In, L, E, never>;
};

declare const findEffect: {
  <A, E2, R2>(
    f: (a: A) => Effect<boolean, E2, R2>,
  ): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option<A>, In, L, E2 | E, R2 | R>;
  <A, In, L, E, R, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (a: A) => Effect<boolean, E2, R2>,
  ): Sink<Option<A>, In, L, E | E2, R | R2>;
};

declare const orElse: {
  <A2, In2, L2, E2, R2>(
    that: LazyArg<Sink<A2, In2, L2, E2, R2>>,
  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    that: LazyArg<Sink<A2, In2, L2, E2, R2>>,
  ): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>;
};

declare const refineOrDie: {
  <E, E2>(
    pf: (error: E) => Option<E2>,
  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(
    self: Sink<A, In, L, E, R>,
    pf: (error: E) => Option<E2>,
  ): Sink<A, In, L, E2, R>;
};

declare const refineOrDieWith: {
  <E, E2>(
    pf: (error: E) => Option<E2>,
    f: (error: E) => unknown,
  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(
    self: Sink<A, In, L, E, R>,
    pf: (error: E) => Option<E2>,
    f: (error: E) => unknown,
  ): Sink<A, In, L, E2, R>;
};

declare const filterInput: {
  <In, In1, In2>(
    f: Refinement<In1, In2>,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>;
  <In, In1>(f: Predicate<In1>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E, R>;
};

declare const filterInputEffect: {
  <In, In1, E2, R2>(
    f: (input: In1) => Effect<boolean, E2, R2>,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In1, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (input: In1) => Effect<boolean, E2, R2>,
  ): Sink<A, In1, L, E | E2, R | R2>;
};

declare const ensuring: {
  <X, R2>(
    finalizer: Effect<X, never, R2>,
  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
  <A, In, L, E, R, X, R2>(
    self: Sink<A, In, L, E, R>,
    finalizer: Effect<X, never, R2>,
  ): Sink<A, In, L, E, R | R2>;
};

declare const ensuringWith: {
  <A, E, X, R2>(
    finalizer: (exit: Exit<A, E>) => Effect<X, never, R2>,
  ): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
  <A, In, L, E, R, X, R2>(
    self: Sink<A, In, L, E, R>,
    finalizer: (exit: Exit<A, E>) => Effect<X, never, R2>,
  ): Sink<A, In, L, E, R | R2>;
};

declare const fold: <S, In>(
  s: S,
  contFn: Predicate<S>,
  f: (s: S, input: In) => S,
) => Sink<S, In, In>;

declare const foldSink: {
  <E, A1, In, In1, L1, E1, R1, A, A2, In2, L2, E2, R2>(options: {
    readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
    readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
  }): <L, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R1 | R2 | R>;
  <A, In, L, E, R, A1, In1, L1, E1, R1, A2, In2, L2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    options: {
      readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
      readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
    },
  ): Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R | R1 | R2>;
};

declare const as: {
  <A2>(a: A2): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
  <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, a: A2): Sink<A2, In, L, E, R>;
};

declare const dimap: {
  <In0, In, A, A2>(options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (input: In0) => In;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
  <A, In, L, E, R, In0, A2>(
    self: Sink<A, In, L, E, R>,
    options: {
      readonly onDone: (a: A) => A2;
      readonly onInput: (input: In0) => In;
    },
  ): Sink<A2, In0, L, E, R>;
};

declare const dimapChunks: {
  <In0, In, A, A2>(options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
  <A, In, L, E, R, In0, A2>(
    self: Sink<A, In, L, E, R>,
    options: {
      readonly onDone: (a: A) => A2;
      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
    },
  ): Sink<A2, In0, L, E, R>;
};

declare const dimapChunksEffect: {
  <In0, In, E2, R2, A, A2, E3, R3>(options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
    self: Sink<A, In, L, E, R>,
    options: {
      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
    },
  ): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
};

declare const dimapEffect: {
  <In0, In, E2, R2, A, A2, E3, R3>(options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
    self: Sink<A, In, L, E, R>,
    options: {
      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
      readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
    },
  ): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
};

declare const map: {
  <A, A2>(f: (a: A) => A2): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
  <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, f: (a: A) => A2): Sink<A2, In, L, E, R>;
};

declare const mapEffect: {
  <A, A2, E2, R2>(
    f: (a: A) => Effect<A2, E2, R2>,
  ): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (a: A) => Effect<A2, E2, R2>,
  ): Sink<A2, In, L, E | E2, R | R2>;
};

declare const mapError: {
  <E, E2>(f: (error: E) => E2): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, f: (error: E) => E2): Sink<A, In, L, E2, R>;
};

declare const mapInput: {
  <In0, In>(
    f: (input: In0) => In,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
  <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (input: In0) => In): Sink<A, In0, L, E, R>;
};

declare const mapInputChunks: {
  <In0, In>(
    f: (chunk: Chunk<In0>) => Chunk<In>,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
  <A, In, L, E, R, In0>(
    self: Sink<A, In, L, E, R>,
    f: (chunk: Chunk<In0>) => Chunk<In>,
  ): Sink<A, In0, L, E, R>;
};

declare const mapInputChunksEffect: {
  <In0, In, E2, R2>(
    f: (chunk: Chunk<In0>) => Effect<Chunk<In>, E2, R2>,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In0, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (chunk: Chunk<In0>) => Effect<Chunk<In>, E2, R2>,
  ): Sink<A, In0, L, E | E2, R | R2>;
};

declare const mapInputEffect: {
  <In0, In, E2, R2>(
    f: (input: In0) => Effect<In, E2, R2>,
  ): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In0, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (input: In0) => Effect<In, E2, R2>,
  ): Sink<A, In0, L, E | E2, R | R2>;
};