@bifravst/aws-cdk-lambda-helpers 5.0.0 → 5.0.1

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/ChainRec.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @since 2.0.0
+ */
+import { Chain, Chain1, Chain2, Chain2C, Chain3, Chain3C, Chain4 } from './Chain'
+import { Either } from './Either'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface ChainRec<F> extends Chain<F> {
+  readonly chainRec: <A, B>(a: A, f: (a: A) => HKT<F, Either<A, B>>) => HKT<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface ChainRec1<F extends URIS> extends Chain1<F> {
+  readonly chainRec: <A, B>(a: A, f: (a: A) => Kind<F, Either<A, B>>) => Kind<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface ChainRec2<F extends URIS2> extends Chain2<F> {
+  readonly chainRec: <E, A, B>(a: A, f: (a: A) => Kind2<F, E, Either<A, B>>) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface ChainRec2C<F extends URIS2, E> extends Chain2C<F, E> {
+  readonly chainRec: <A, B>(a: A, f: (a: A) => Kind2<F, E, Either<A, B>>) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface ChainRec3<F extends URIS3> extends Chain3<F> {
+  readonly chainRec: <R, E, A, B>(a: A, f: (a: A) => Kind3<F, R, E, Either<A, B>>) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface ChainRec3C<F extends URIS3, E> extends Chain3C<F, E> {
+  readonly chainRec: <R, A, B>(a: A, f: (a: A) => Kind3<F, R, E, Either<A, B>>) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface ChainRec4<F extends URIS4> extends Chain4<F> {
+  readonly chainRec: <S, R, E, A, B>(a: A, f: (a: A) => Kind4<F, S, R, E, Either<A, B>>) => Kind4<F, S, R, E, B>
+}
+/**
+ * @since 2.0.0
+ */
+export declare const tailRec: <A, B>(startWith: A, f: (a: A) => Either<A, B>) => B

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/ChainRec.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tailRec = void 0;
+/**
+ * @since 2.0.0
+ */
+var tailRec = function (startWith, f) {
+    var ab = f(startWith);
+    while (ab._tag === 'Left') {
+        ab = f(ab.left);
+    }
+    return ab.right;
+};
+exports.tailRec = tailRec;

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Choice.d.ts

@@ -0,0 +1,174 @@
+/**
+ * The `Choice` class extends `Profunctor` with combinators for working with
+ * sum types.
+ *
+ * `left` and `right` lift values in a `Profunctor` to act on the `Left` and
+ * `Right` components of a sum, respectively.
+ *
+ * Looking at `Choice` through the intuition of inputs and outputs
+ * yields the following type signature:
+ *
+ * ```purescript
+ * left ::  forall input output a. p input output -> p (Either input a) (Either output a)
+ * right :: forall input output a. p input output -> p (Either a input) (Either a output)
+ * ```
+ *
+ * If we specialize the profunctor `p` to the `function` arrow, we get the following type
+ * signatures:
+ *
+ * ```purescript
+ * left ::  forall input output a. (input -> output) -> (Either input a) -> (Either output a)
+ * right :: forall input output a. (input -> output) -> (Either a input) -> (Either a output)
+ * ```
+ *
+ * When the `profunctor` is `Function` application, `left` allows you to map a function over the
+ * left side of an `Either`, and `right` maps it over the right side (same as `map` would do).
+ *
+ * Adapted from https://github.com/purescript/purescript-profunctor/blob/master/src/Data/Profunctor/Choice.purs
+ *
+ * @since 2.0.0
+ */
+import { Category, Category2, Category3, Category4 } from './Category'
+import { Either } from './Either'
+import { HKT2, Kind2, Kind3, Kind4, URIS2, URIS3, URIS4 } from './HKT'
+import { Profunctor, Profunctor2, Profunctor3, Profunctor4 } from './Profunctor'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Choice<F> extends Profunctor<F> {
+  readonly left: <A, B, C>(pab: HKT2<F, A, B>) => HKT2<F, Either<A, C>, Either<B, C>>
+  readonly right: <A, B, C>(pbc: HKT2<F, B, C>) => HKT2<F, Either<A, B>, Either<A, C>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Choice2<F extends URIS2> extends Profunctor2<F> {
+  readonly left: <A, B, C>(pab: Kind2<F, A, B>) => Kind2<F, Either<A, C>, Either<B, C>>
+  readonly right: <A, B, C>(pbc: Kind2<F, B, C>) => Kind2<F, Either<A, B>, Either<A, C>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Choice3<F extends URIS3> extends Profunctor3<F> {
+  readonly left: <R, A, B, C>(pab: Kind3<F, R, A, B>) => Kind3<F, R, Either<A, C>, Either<B, C>>
+  readonly right: <R, A, B, C>(pbc: Kind3<F, R, B, C>) => Kind3<F, R, Either<A, B>, Either<A, C>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Choice4<F extends URIS4> extends Profunctor4<F> {
+  readonly left: <S, R, A, B, C>(pab: Kind4<F, S, R, A, B>) => Kind4<F, S, R, Either<A, C>, Either<B, C>>
+  readonly right: <S, R, A, B, C>(pbc: Kind4<F, S, R, B, C>) => Kind4<F, S, R, Either<A, B>, Either<A, C>>
+}
+/**
+ * Compose a value acting on a sum from two values, each acting on one of
+ * the components of the sum.
+ *
+ * Specializing `split` to function application would look like this:
+ *
+ * ```purescript
+ * split :: forall a b c d. (a -> b) -> (c -> d) -> (Either a c) -> (Either b d)
+ * ```
+ *
+ * We take two functions, `f` and `g`, and we transform them into a single function which
+ * takes an `Either`and maps `f` over the left side and `g` over the right side.  Just like
+ * `bimap` would do for the `Bifunctor` instance of `Either`.
+ *
+ * @since 2.10.0
+ */
+export declare function split<P extends URIS4>(
+  P: Choice4<P>,
+  C: Category4<P>
+): <S, R, A, B, C, D>(
+  pab: Kind4<P, S, R, A, B>,
+  pcd: Kind4<P, S, R, C, D>
+) => Kind4<P, S, R, Either<A, C>, Either<B, D>>
+export declare function split<P extends URIS3>(
+  P: Choice3<P>,
+  C: Category3<P>
+): <R, A, B, C, D>(pab: Kind3<P, R, A, B>, pcd: Kind3<P, R, C, D>) => Kind3<P, R, Either<A, C>, Either<B, D>>
+export declare function split<P extends URIS2>(
+  P: Choice2<P>,
+  C: Category2<P>
+): <A, B, C, D>(pab: Kind2<P, A, B>, pcd: Kind2<P, C, D>) => Kind2<P, Either<A, C>, Either<B, D>>
+export declare function split<P>(
+  P: Choice<P>,
+  C: Category<P>
+): <A, B, C, D>(pab: HKT2<P, A, B>, pcd: HKT2<P, C, D>) => HKT2<P, Either<A, C>, Either<B, D>>
+/**
+ * Compose a value which eliminates a sum from two values, each eliminating
+ * one side of the sum.
+ *
+ * This combinator is useful when assembling values from smaller components,
+ * because it provides a way to support two different types of input.
+ *
+ * Specializing `fanIn` to function application would look like this:
+ *
+ * ```purescript
+ * fanIn :: forall a b c d. (a -> c) -> (b -> c) -> Either a b -> c
+ * ```
+ *
+ * We take two functions, `f` and `g`, which both return the same type `c` and we transform them into a
+ * single function which takes an `Either` value with the parameter type of `f` on the left side and
+ * the parameter type of `g` on the right side. The function then runs either `f` or `g`, depending on
+ * whether the `Either` value is a `Left` or a `Right`.
+ * This allows us to bundle two different computations which both have the same result type into one
+ * function which will run the appropriate computation based on the parameter supplied in the `Either` value.
+ *
+ * @since 2.10.0
+ */
+export declare function fanIn<P extends URIS4>(
+  P: Choice4<P>,
+  C: Category4<P>
+): <S, R, A, B, C>(pac: Kind4<P, S, R, A, C>, pbc: Kind4<P, S, R, B, C>) => Kind4<P, S, R, Either<A, B>, C>
+export declare function fanIn<P extends URIS3>(
+  P: Choice3<P>,
+  C: Category3<P>
+): <R, A, B, C>(pac: Kind3<P, R, A, C>, pbc: Kind3<P, R, B, C>) => Kind3<P, R, Either<A, B>, C>
+export declare function fanIn<P extends URIS2>(
+  P: Choice2<P>,
+  C: Category2<P>
+): <A, B, C>(pac: Kind2<P, A, C>, pbc: Kind2<P, B, C>) => Kind2<P, Either<A, B>, C>
+export declare function fanIn<P>(
+  P: Choice<P>,
+  C: Category<P>
+): <A, B, C>(pac: HKT2<P, A, C>, pbc: HKT2<P, B, C>) => HKT2<P, Either<A, B>, C>
+/**
+ * Use [`split`](#split) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function splitChoice<F extends URIS3>(
+  F: Category3<F> & Choice3<F>
+): <R, A, B, C, D>(pab: Kind3<F, R, A, B>, pcd: Kind3<F, R, C, D>) => Kind3<F, R, Either<A, C>, Either<B, D>>
+/** @deprecated */
+export declare function splitChoice<F extends URIS2>(
+  F: Category2<F> & Choice2<F>
+): <A, B, C, D>(pab: Kind2<F, A, B>, pcd: Kind2<F, C, D>) => Kind2<F, Either<A, C>, Either<B, D>>
+/** @deprecated */
+export declare function splitChoice<F>(
+  F: Category<F> & Choice<F>
+): <A, B, C, D>(pab: HKT2<F, A, B>, pcd: HKT2<F, C, D>) => HKT2<F, Either<A, C>, Either<B, D>>
+/**
+ * Use [`fanIn`](#fanIn) instead.
+ *
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function fanin<F extends URIS3>(
+  F: Category3<F> & Choice3<F>
+): <R, A, B, C>(pac: Kind3<F, R, A, C>, pbc: Kind3<F, R, B, C>) => Kind3<F, R, Either<A, B>, C>
+/** @deprecated */
+export declare function fanin<F extends URIS2>(
+  F: Category2<F> & Choice2<F>
+): <A, B, C>(pac: Kind2<F, A, C>, pbc: Kind2<F, B, C>) => Kind2<F, Either<A, B>, C>
+/** @deprecated */
+export declare function fanin<F>(
+  F: Category<F> & Choice<F>
+): <A, B, C>(pac: HKT2<F, A, C>, pbc: HKT2<F, B, C>) => HKT2<F, Either<A, B>, C>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Choice.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = split;
+exports.fanIn = fanIn;
+exports.splitChoice = splitChoice;
+exports.fanin = fanin;
+var function_1 = require("./function");
+function split(P, C) {
+    return function (pab, pcd) { return C.compose(P.right(pcd), P.left(pab)); };
+}
+function fanIn(P, C) {
+    var splitPC = split(P, C);
+    return function (pac, pbc) {
+        return C.compose(P.promap(C.id(), function (cc) { return (cc._tag === 'Left' ? cc.left : cc.right); }, function_1.identity), splitPC(pac, pbc));
+    };
+}
+function splitChoice(F) {
+    return split(F, F);
+}
+function fanin(F) {
+    return fanIn(F, F);
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Comonad.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @since 2.0.0
+ */
+import { Extend, Extend1, Extend2, Extend2C, Extend3, Extend3C, Extend4 } from './Extend'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Comonad<W> extends Extend<W> {
+  readonly extract: <A>(wa: HKT<W, A>) => A
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Comonad1<W extends URIS> extends Extend1<W> {
+  readonly extract: <A>(wa: Kind<W, A>) => A
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Comonad2<W extends URIS2> extends Extend2<W> {
+  readonly extract: <E, A>(wa: Kind2<W, E, A>) => A
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Comonad2C<W extends URIS2, E> extends Extend2C<W, E> {
+  readonly extract: <A>(wa: Kind2<W, E, A>) => A
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Comonad3<W extends URIS3> extends Extend3<W> {
+  readonly extract: <R, E, A>(wa: Kind3<W, R, E, A>) => A
+}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface Comonad3C<W extends URIS3, E> extends Extend3C<W, E> {
+  readonly extract: <R, A>(wa: Kind3<W, R, E, A>) => A
+}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface Comonad4<W extends URIS4> extends Extend4<W> {
+  readonly extract: <S, R, E, A>(wa: Kind4<W, S, R, E, A>) => A
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Comonad.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Compactable.d.ts

@@ -0,0 +1,320 @@
+/**
+ * `Compactable` represents data structures which can be _compacted_/_filtered_. This is a generalization of
+ * `catOptions` as a new function `compact`. `compact` has relations with `Functor`, `Applicative`,
+ * `Monad`, `Alternative`, and `Traversable` in that we can use these classes to provide the ability to
+ * operate on a data type by eliminating intermediate `None`s. This is useful for representing the filtering out of
+ * values, or failure.
+ *
+ * Adapted from https://github.com/LiamGoodacre/purescript-filterable/blob/master/src/Data/Compactable.purs
+ *
+ * @since 2.0.0
+ */
+import { Either } from './Either'
+import {
+  Functor,
+  Functor1,
+  Functor2,
+  Functor2C,
+  Functor3C,
+  FunctorComposition,
+  FunctorComposition2C1,
+  FunctorComposition11,
+  FunctorComposition12,
+  FunctorComposition12C,
+  FunctorComposition21,
+  FunctorComposition22,
+  FunctorComposition22C,
+  FunctorComposition23,
+  FunctorComposition23C
+} from './Functor'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Option } from './Option'
+import * as S from './Separated'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable<F> {
+  readonly URI: F
+  /**
+   * Compacts a data structure unwrapping inner Option
+   */
+  readonly compact: <A>(fa: HKT<F, Option<A>>) => HKT<F, A>
+  /**
+   * Separates a data structure moving inner Left to the left side and inner Right to the right side of Separated
+   */
+  readonly separate: <A, B>(fa: HKT<F, Either<A, B>>) => S.Separated<HKT<F, A>, HKT<F, B>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable1<F extends URIS> {
+  readonly URI: F
+  readonly compact: <A>(fa: Kind<F, Option<A>>) => Kind<F, A>
+  readonly separate: <A, B>(fa: Kind<F, Either<A, B>>) => S.Separated<Kind<F, A>, Kind<F, B>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable2<F extends URIS2> {
+  readonly URI: F
+  readonly compact: <E, A>(fa: Kind2<F, E, Option<A>>) => Kind2<F, E, A>
+  readonly separate: <E, A, B>(fa: Kind2<F, E, Either<A, B>>) => S.Separated<Kind2<F, E, A>, Kind2<F, E, B>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable2C<F extends URIS2, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly compact: <A>(fa: Kind2<F, E, Option<A>>) => Kind2<F, E, A>
+  readonly separate: <A, B>(fa: Kind2<F, E, Either<A, B>>) => S.Separated<Kind2<F, E, A>, Kind2<F, E, B>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable3<F extends URIS3> {
+  readonly URI: F
+  readonly compact: <R, E, A>(fa: Kind3<F, R, E, Option<A>>) => Kind3<F, R, E, A>
+  readonly separate: <R, E, A, B>(fa: Kind3<F, R, E, Either<A, B>>) => S.Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Compactable3C<F extends URIS3, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly compact: <R, A>(fa: Kind3<F, R, E, Option<A>>) => Kind3<F, R, E, A>
+  readonly separate: <R, A, B>(fa: Kind3<F, R, E, Either<A, B>>) => S.Separated<Kind3<F, R, E, A>, Kind3<F, R, E, B>>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Compactable4<F extends URIS4> {
+  readonly URI: F
+  readonly compact: <S, R, E, A>(fa: Kind4<F, S, R, E, Option<A>>) => Kind4<F, S, R, E, A>
+  readonly separate: <S, R, E, A, B>(
+    fa: Kind4<F, S, R, E, Either<A, B>>
+  ) => S.Separated<Kind4<F, S, R, E, A>, Kind4<F, S, R, E, B>>
+}
+/**
+ * `compact` composition.
+ *
+ * @since 2.10.0
+ */
+export declare function compact<F extends URIS2, G extends URIS2, E>(
+  F: Functor2<F>,
+  G: Compactable2C<G, E>
+): <FE, A>(fa: Kind2<F, FE, Kind2<G, E, Option<A>>>) => Kind2<F, FE, Kind2<G, E, A>>
+export declare function compact<F extends URIS, G extends URIS2, E>(
+  F: Functor1<F>,
+  G: Compactable2C<G, E>
+): <A>(fa: Kind<F, Kind2<G, E, Option<A>>>) => Kind<F, Kind2<G, E, A>>
+export declare function compact<F extends URIS, G extends URIS>(
+  F: Functor1<F>,
+  G: Compactable1<G>
+): <A>(fa: Kind<F, Kind<G, Option<A>>>) => Kind<F, Kind<G, A>>
+export declare function compact<F, G>(
+  F: Functor<F>,
+  G: Compactable<G>
+): <A>(fa: HKT<F, HKT<G, Option<A>>>) => HKT<F, HKT<G, A>>
+/**
+ * `separate` composition.
+ *
+ * @since 2.10.0
+ */
+export declare function separate<F extends URIS2, G extends URIS2, E>(
+  F: Functor2<F>,
+  C: Compactable2C<G, E>,
+  G: Functor2<G>
+): <FE, A, B>(
+  fge: Kind2<F, FE, Kind2<G, E, Either<A, B>>>
+) => S.Separated<Kind2<F, FE, Kind2<G, E, A>>, Kind2<F, FE, Kind2<G, E, B>>>
+export declare function separate<F extends URIS, G extends URIS2, E>(
+  F: Functor1<F>,
+  C: Compactable2C<G, E>,
+  G: Functor2<G>
+): <A, B>(fge: Kind<F, Kind2<G, E, Either<A, B>>>) => S.Separated<Kind<F, Kind2<G, E, A>>, Kind<F, Kind2<G, E, B>>>
+export declare function separate<F extends URIS, G extends URIS>(
+  F: Functor1<F>,
+  C: Compactable1<G>,
+  G: Functor1<G>
+): <A, B>(fge: Kind<F, Kind<G, Either<A, B>>>) => S.Separated<Kind<F, Kind<G, A>>, Kind<F, Kind<G, B>>>
+export declare function separate<F, G>(
+  F: Functor<F>,
+  C: Compactable<G>,
+  G: Functor<G>
+): <A, B>(fge: HKT<F, HKT<G, Either<A, B>>>) => S.Separated<HKT<F, HKT<G, A>>, HKT<F, HKT<G, B>>>
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition<F, G> extends FunctorComposition<F, G> {
+  readonly compact: <A>(fga: HKT<F, HKT<G, Option<A>>>) => HKT<F, HKT<G, A>>
+  readonly separate: <A, B>(fge: HKT<F, HKT<G, Either<A, B>>>) => Separated<HKT<F, HKT<G, A>>, HKT<F, HKT<G, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition11<F extends URIS, G extends URIS> extends FunctorComposition11<F, G> {
+  readonly compact: <A>(fga: Kind<F, Kind<G, Option<A>>>) => Kind<F, Kind<G, A>>
+  readonly separate: <A, B>(fge: Kind<F, Kind<G, Either<A, B>>>) => Separated<Kind<F, Kind<G, A>>, Kind<F, Kind<G, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition12<F extends URIS, G extends URIS2> extends FunctorComposition12<F, G> {
+  readonly compact: <E, A>(fga: Kind<F, Kind2<G, E, Option<A>>>) => Kind<F, Kind2<G, E, A>>
+  readonly separate: <E, A, B>(
+    fge: Kind<F, Kind2<G, E, Either<A, B>>>
+  ) => Separated<Kind<F, Kind2<G, E, A>>, Kind<F, Kind2<G, E, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition12C<F extends URIS, G extends URIS2, E> extends FunctorComposition12C<F, G, E> {
+  readonly compact: <A>(fga: Kind<F, Kind2<G, E, Option<A>>>) => Kind<F, Kind2<G, E, A>>
+  readonly separate: <A, B>(
+    fge: Kind<F, Kind2<G, E, Either<A, B>>>
+  ) => Separated<Kind<F, Kind2<G, E, A>>, Kind<F, Kind2<G, E, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition21<F extends URIS2, G extends URIS> extends FunctorComposition21<F, G> {
+  readonly compact: <FE, A>(fga: Kind2<F, FE, Kind<G, Option<A>>>) => Kind2<F, FE, Kind<G, A>>
+  readonly separate: <FE, A, B>(
+    fge: Kind2<F, FE, Kind<G, Either<A, B>>>
+  ) => Separated<Kind2<F, FE, Kind<G, A>>, Kind2<F, FE, Kind<G, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition2C1<F extends URIS2, G extends URIS, E> extends FunctorComposition2C1<F, G, E> {
+  readonly compact: <A>(fga: Kind2<F, E, Kind<G, Option<A>>>) => Kind2<F, E, Kind<G, A>>
+  readonly separate: <A, B>(
+    fge: Kind2<F, E, Kind<G, Either<A, B>>>
+  ) => Separated<Kind2<F, E, Kind<G, A>>, Kind2<F, E, Kind<G, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition22<F extends URIS2, G extends URIS2> extends FunctorComposition22<F, G> {
+  readonly compact: <FE, GE, A>(fga: Kind2<F, FE, Kind2<G, GE, Option<A>>>) => Kind2<F, FE, Kind2<G, GE, A>>
+  readonly separate: <FE, GE, A, B>(
+    fge: Kind2<F, FE, Kind2<G, GE, Either<A, B>>>
+  ) => Separated<Kind2<F, FE, Kind2<G, GE, A>>, Kind2<F, FE, Kind2<G, GE, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface CompactableComposition22C<F extends URIS2, G extends URIS2, E> extends FunctorComposition22C<F, G, E> {
+  readonly compact: <FE, A>(fga: Kind2<F, FE, Kind2<G, E, Option<A>>>) => Kind2<F, FE, Kind2<G, E, A>>
+  readonly separate: <FE, A, B>(
+    fge: Kind2<F, FE, Kind2<G, E, Either<A, B>>>
+  ) => Separated<Kind2<F, FE, Kind2<G, E, A>>, Kind2<F, FE, Kind2<G, E, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.2.0
+ * @deprecated
+ */
+export interface CompactableComposition23<F extends URIS2, G extends URIS3> extends FunctorComposition23<F, G> {
+  readonly compact: <R, FE, GE, A>(fga: Kind2<F, FE, Kind3<G, R, GE, Option<A>>>) => Kind2<F, FE, Kind3<G, R, GE, A>>
+  readonly separate: <R, FE, GE, A, B>(
+    fge: Kind2<F, FE, Kind3<G, R, GE, Either<A, B>>>
+  ) => Separated<Kind2<F, FE, Kind3<G, R, GE, A>>, Kind2<F, FE, Kind3<G, R, GE, B>>>
+}
+/**
+ * @category zone of death
+ * @since 2.2.0
+ * @deprecated
+ */
+export interface CompactableComposition23C<F extends URIS2, G extends URIS3, E> extends FunctorComposition23C<F, G, E> {
+  readonly compact: <FE, R, A>(fga: Kind2<F, FE, Kind3<G, R, E, Option<A>>>) => Kind2<F, FE, Kind3<G, R, E, A>>
+  readonly separate: <FE, R, A, B>(
+    fge: Kind2<F, FE, Kind3<G, R, E, Either<A, B>>>
+  ) => Separated<Kind2<F, FE, Kind3<G, R, E, A>>, Kind2<F, FE, Kind3<G, R, E, B>>>
+}
+/**
+ * Use [`compact`](#compact) and [`separate`](#separate) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function getCompactableComposition<F extends URIS2, G extends URIS3, E>(
+  F: Functor2<F>,
+  G: Compactable3C<G, E> & Functor3C<G, E>
+): CompactableComposition23C<F, G, E>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS2, G extends URIS2, E>(
+  F: Functor2<F>,
+  G: Compactable2C<G, E> & Functor2C<G, E>
+): CompactableComposition22C<F, G, E>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS2, G extends URIS2>(
+  F: Functor2<F>,
+  G: Compactable2<G> & Functor2<G>
+): CompactableComposition22<F, G>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS2, G extends URIS, E>(
+  F: Functor2C<F, E>,
+  G: Compactable1<G> & Functor1<G>
+): CompactableComposition2C1<F, G, E>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS2, G extends URIS>(
+  F: Functor2<F>,
+  G: Compactable1<G> & Functor1<G>
+): CompactableComposition21<F, G>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS, G extends URIS2, E>(
+  F: Functor1<F>,
+  G: Compactable2C<G, E> & Functor2C<G, E>
+): CompactableComposition12<F, G>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS, G extends URIS2>(
+  F: Functor1<F>,
+  G: Compactable2<G> & Functor2<G>
+): CompactableComposition12<F, G>
+/** @deprecated */
+export declare function getCompactableComposition<F extends URIS, G extends URIS>(
+  F: Functor1<F>,
+  G: Compactable1<G> & Functor1<G>
+): CompactableComposition11<F, G>
+/** @deprecated */
+export declare function getCompactableComposition<F, G>(
+  F: Functor<F>,
+  G: Compactable<G> & Functor<G>
+): CompactableComposition<F, G>
+/**
+ * Use [`Separated`](./Separated.ts.html#separated) instead.
+ *
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface Separated<A, B> {
+  readonly left: A
+  readonly right: B
+}