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

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/struct.d.ts

@@ -0,0 +1,42 @@
+import { Semigroup } from './Semigroup'
+/**
+ * Return a semigroup which works like `Object.assign`.
+ *
+ * @example
+ * import { getAssignSemigroup } from 'fp-ts/struct'
+ *
+ * interface Person {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const S = getAssignSemigroup<Person>()
+ * assert.deepStrictEqual(S.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getAssignSemigroup: <A extends object = never>() => Semigroup<A>
+/**
+ * Creates a new object by recursively evolving a shallow copy of `a`, according to the `transformation` functions.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import { evolve } from 'fp-ts/struct'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1 },
+ *     evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2 }
+ * )
+ *
+ * @since 2.11.0
+ */
+export declare const evolve: <A, F extends { [K in keyof A]: (a: A[K]) => unknown }>(
+  transformations: F
+) => (a: A) => { [K in keyof F]: ReturnType<F[K]> }

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/struct.js

@@ -0,0 +1,61 @@
+/**
+ * @since 2.10.0
+ */
+import * as _ from './internal';
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * Return a semigroup which works like `Object.assign`.
+ *
+ * @example
+ * import { getAssignSemigroup } from 'fp-ts/struct'
+ *
+ * interface Person {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const S = getAssignSemigroup<Person>()
+ * assert.deepStrictEqual(S.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var getAssignSemigroup = function () { return ({
+    concat: function (first, second) { return Object.assign({}, first, second); }
+}); };
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Creates a new object by recursively evolving a shallow copy of `a`, according to the `transformation` functions.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import { evolve } from 'fp-ts/struct'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1 },
+ *     evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2 }
+ * )
+ *
+ * @since 2.11.0
+ */
+export var evolve = function (transformations) {
+    return function (a) {
+        var out = {};
+        for (var k in a) {
+            if (_.has.call(a, k)) {
+                out[k] = transformations[k](a[k]);
+            }
+        }
+        return out;
+    };
+};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/void.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @since 2.11.0
+ */
+import * as M from './Monoid'
+import * as Se from './Semigroup'
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const Semigroup: Se.Semigroup<void>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const Monoid: M.Monoid<void>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/void.js

@@ -0,0 +1,17 @@
+import * as Se from './Semigroup';
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var Semigroup = Se.constant(undefined);
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var Monoid = {
+    concat: Semigroup.concat,
+    empty: undefined
+};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/function/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/function.js",
+  "module": "../es6/function.js",
+  "typings": "../lib/function.d.ts",
+  "sideEffects": false
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/internal/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/internal.js",
+  "module": "../es6/internal.js",
+  "typings": "../lib/internal.d.ts",
+  "sideEffects": false
+}

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

@@ -0,0 +1,86 @@
+/**
+ * The `Alt` type class identifies an associative operation on a type constructor.  It is similar to `Semigroup`, except
+ * that it applies to types of kind `* -> *`, like `Array` or `Option`, rather than concrete types like `string` or
+ * `number`.
+ *
+ * `Alt` instances are required to satisfy the following laws:
+ *
+ * 1. Associativity: `A.alt(A.alt(fa, ga), ha) <-> A.alt(fa, A.alt(ga, ha))`
+ * 2. Distributivity: `A.map(A.alt(fa, ga), ab) <-> A.alt(A.map(fa, ab), A.map(ga, ab))`
+ *
+ * @since 2.0.0
+ */
+import { LazyArg } from './function'
+import { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C, Functor4 } from './Functor'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt<F> extends Functor<F> {
+  readonly alt: <A>(fa: HKT<F, A>, that: LazyArg<HKT<F, A>>) => HKT<F, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt1<F extends URIS> extends Functor1<F> {
+  readonly alt: <A>(fa: Kind<F, A>, that: LazyArg<Kind<F, A>>) => Kind<F, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt2<F extends URIS2> extends Functor2<F> {
+  readonly alt: <E, A>(fa: Kind2<F, E, A>, that: LazyArg<Kind2<F, E, A>>) => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt2C<F extends URIS2, E> extends Functor2C<F, E> {
+  readonly alt: <A>(fa: Kind2<F, E, A>, that: LazyArg<Kind2<F, E, A>>) => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt3<F extends URIS3> extends Functor3<F> {
+  readonly alt: <R, E, A>(fa: Kind3<F, R, E, A>, that: LazyArg<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Alt3C<F extends URIS3, E> extends Functor3C<F, E> {
+  readonly alt: <R, A>(fa: Kind3<F, R, E, A>, that: LazyArg<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alt4<F extends URIS4> extends Functor4<F> {
+  readonly alt: <S, R, E, A>(fa: Kind4<F, S, R, E, A>, that: LazyArg<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
+}
+/**
+ * @since 2.11.0
+ */
+export declare function altAll<F extends URIS4>(
+  F: Alt4<F>
+): <S, R, E, A>(startWith: Kind4<F, S, R, E, A>) => (as: ReadonlyArray<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
+export declare function altAll<F extends URIS3>(
+  F: Alt3<F>
+): <R, E, A>(startWith: Kind3<F, R, E, A>) => (as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+export declare function altAll<F extends URIS3, E>(
+  F: Alt3C<F, E>
+): <R, A>(startWith: Kind3<F, R, E, A>) => (as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+export declare function altAll<F extends URIS2>(
+  F: Alt2<F>
+): <E, A>(startWith: Kind2<F, E, A>) => (as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
+export declare function altAll<F extends URIS2, E>(
+  F: Alt2C<F, E>
+): <A>(startWith: Kind2<F, E, A>) => (as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
+export declare function altAll<F extends URIS>(
+  F: Alt1<F>
+): <A>(startWith: Kind<F, A>) => (as: ReadonlyArray<Kind<F, A>>) => Kind<F, A>
+export declare function altAll<F>(F: Alt<F>): <A>(startWith: HKT<F, A>) => (as: ReadonlyArray<HKT<F, A>>) => HKT<F, A>

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.altAll = altAll;
+function altAll(F) {
+    return function (startWith) { return function (as) { return as.reduce(function (acc, a) { return F.alt(acc, function () { return a; }); }, startWith); }; };
+}

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

@@ -0,0 +1,108 @@
+/**
+ * The `Alternative` type class extends the `Alt` type class with a value that should be the left and right identity for `alt`.
+ *
+ * It is similar to `Monoid`, except that it applies to types of kind `* -> *`, like `Array` or `Option`, rather than
+ * concrete types like `string` or `number`.
+ *
+ * `Alternative` instances should satisfy the following laws:
+ *
+ * 1. Left identity: `A.alt(zero, fa) <-> fa`
+ * 2. Right identity: `A.alt(fa, zero) <-> fa`
+ * 3. Annihilation: `A.map(zero, f) <-> zero`
+ * 4. Distributivity: `A.ap(A.alt(fab, gab), fa) <-> A.alt(A.ap(fab, fa), A.ap(gab, fa))`
+ * 5. Annihilation: `A.ap(zero, fa) <-> zero`
+ *
+ * @since 2.0.0
+ */
+import { Alt, Alt1, Alt2, Alt2C, Alt3, Alt3C, Alt4 } from './Alt'
+import {
+  Applicative,
+  Applicative1,
+  Applicative2,
+  Applicative2C,
+  Applicative3,
+  Applicative3C,
+  Applicative4
+} from './Applicative'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Monoid } from './Monoid'
+import { Semigroup } from './Semigroup'
+import { Zero, Zero1, Zero2, Zero2C, Zero3, Zero3C, Zero4 } from './Zero'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alternative<F> extends Applicative<F>, Alt<F>, Zero<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alternative1<F extends URIS> extends Applicative1<F>, Alt1<F>, Zero1<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alternative2<F extends URIS2> extends Applicative2<F>, Alt2<F>, Zero2<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alternative2C<F extends URIS2, E> extends Applicative2C<F, E>, Alt2C<F, E>, Zero2C<F, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Alternative3<F extends URIS3> extends Applicative3<F>, Alt3<F>, Zero3<F> {}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface Alternative3C<F extends URIS3, E> extends Applicative3C<F, E>, Alt3C<F, E>, Zero3C<F, E> {}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface Alternative4<F extends URIS4> extends Applicative4<F>, Alt4<F>, Zero4<F> {}
+/**
+ * @since 2.11.0
+ */
+export declare function altAll<F extends URIS4>(
+  F: Alternative4<F>
+): <S, R, E, A>(as: ReadonlyArray<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
+export declare function altAll<F extends URIS3>(
+  F: Alternative3<F>
+): <R, E, A>(as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+export declare function altAll<F extends URIS3, E>(
+  F: Alternative3C<F, E>
+): <R, A>(as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
+export declare function altAll<F extends URIS2>(
+  F: Alternative2<F>
+): <E, A>(as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
+export declare function altAll<F extends URIS2, E>(
+  F: Alternative2C<F, E>
+): <A>(as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
+export declare function altAll<F extends URIS>(F: Alternative1<F>): <A>(as: ReadonlyArray<Kind<F, A>>) => Kind<F, A>
+export declare function altAll<F>(F: Alternative<F>): <A>(as: ReadonlyArray<HKT<F, A>>) => HKT<F, A>
+/**
+ * Lift a semigroup into a monoid alternative 'F', the inner values are concatenated using the provided `Semigroup`.
+ * @since 2.13.0
+ */
+export declare function getAlternativeMonoid<F extends URIS4>(
+  F: Alternative4<F>
+): <A, S, R, E>(S: Semigroup<A>) => Monoid<Kind4<F, S, R, E, A>>
+export declare function getAlternativeMonoid<F extends URIS3>(
+  F: Alternative3<F>
+): <A, R, E>(S: Semigroup<A>) => Monoid<Kind3<F, R, E, A>>
+export declare function getAlternativeMonoid<F extends URIS3, E>(
+  F: Alternative3C<F, E>
+): <A, R>(S: Semigroup<A>) => Monoid<Kind3<F, R, E, A>>
+export declare function getAlternativeMonoid<F extends URIS2>(
+  F: Alternative2<F>
+): <A, E>(S: Semigroup<A>) => Monoid<Kind2<F, E, A>>
+export declare function getAlternativeMonoid<F extends URIS2, E>(
+  F: Alternative2C<F, E>
+): <A>(S: Semigroup<A>) => Monoid<Kind2<F, E, A>>
+export declare function getAlternativeMonoid<F extends URIS>(
+  F: Alternative1<F>
+): <A>(S: Semigroup<A>) => Monoid<Kind<F, A>>
+export declare function getAlternativeMonoid<F>(F: Alternative<F>): <A>(S: Semigroup<A>) => Monoid<HKT<F, A>>

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.altAll = altAll;
+exports.getAlternativeMonoid = getAlternativeMonoid;
+/**
+ * The `Alternative` type class extends the `Alt` type class with a value that should be the left and right identity for `alt`.
+ *
+ * It is similar to `Monoid`, except that it applies to types of kind `* -> *`, like `Array` or `Option`, rather than
+ * concrete types like `string` or `number`.
+ *
+ * `Alternative` instances should satisfy the following laws:
+ *
+ * 1. Left identity: `A.alt(zero, fa) <-> fa`
+ * 2. Right identity: `A.alt(fa, zero) <-> fa`
+ * 3. Annihilation: `A.map(zero, f) <-> zero`
+ * 4. Distributivity: `A.ap(A.alt(fab, gab), fa) <-> A.alt(A.ap(fab, fa), A.ap(gab, fa))`
+ * 5. Annihilation: `A.ap(zero, fa) <-> zero`
+ *
+ * @since 2.0.0
+ */
+var Alt_1 = require("./Alt");
+var Apply_1 = require("./Apply");
+function altAll(F) {
+    return (0, Alt_1.altAll)(F)(F.zero());
+}
+function getAlternativeMonoid(F) {
+    var f = (0, Apply_1.getApplySemigroup)(F);
+    return function (S) {
+        var SF = f(S);
+        return {
+            concat: function (first, second) {
+                return F.alt(SF.concat(first, second), function () { return F.alt(first, function () { return second; }); });
+            },
+            empty: F.zero()
+        };
+    };
+}

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

@@ -0,0 +1,267 @@
+/**
+ * The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values
+ * of type `f a` from values of type `a`.
+ *
+ * Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are
+ * wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the
+ * function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for
+ * any number of function arguments.
+ *
+ * Instances must satisfy the following laws in addition to the `Apply` laws:
+ *
+ * 1. Identity: `A.ap(A.of(a => a), fa) <-> fa`
+ * 2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`
+ * 3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`
+ *
+ * Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`
+ *
+ * @since 2.0.0
+ */
+import { Apply, Apply1, Apply2, Apply2C, Apply3, Apply3C, Apply4 } from './Apply'
+import {
+  FunctorComposition,
+  FunctorComposition2C1,
+  FunctorComposition11,
+  FunctorComposition12,
+  FunctorComposition12C,
+  FunctorComposition21,
+  FunctorComposition22,
+  FunctorComposition22C,
+  FunctorCompositionHKT1,
+  FunctorCompositionHKT2,
+  FunctorCompositionHKT2C
+} from './Functor'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Monoid } from './Monoid'
+import { Pointed, Pointed1, Pointed2, Pointed2C, Pointed3, Pointed3C, Pointed4 } from './Pointed'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative<F> extends Apply<F>, Pointed<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative1<F extends URIS> extends Apply1<F>, Pointed1<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative2<F extends URIS2> extends Apply2<F>, Pointed2<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative2C<F extends URIS2, E> extends Apply2C<F, E>, Pointed2C<F, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative3<F extends URIS3> extends Apply3<F>, Pointed3<F> {}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Applicative3C<F extends URIS3, E> extends Apply3C<F, E>, Pointed3C<F, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Applicative4<F extends URIS4> extends Apply4<F>, Pointed4<F> {}
+/**
+ * Lift a monoid into 'F', the inner values are concatenated using the provided `Monoid`.
+ *
+ * @since 2.10.0
+ */
+export declare function getApplicativeMonoid<F extends URIS4>(
+  F: Applicative4<F>
+): <A, S, R, E>(M: Monoid<A>) => Monoid<Kind4<F, S, R, E, A>>
+export declare function getApplicativeMonoid<F extends URIS3>(
+  F: Applicative3<F>
+): <A, R, E>(M: Monoid<A>) => Monoid<Kind3<F, R, E, A>>
+export declare function getApplicativeMonoid<F extends URIS3, E>(
+  F: Applicative3C<F, E>
+): <A, R>(M: Monoid<A>) => Monoid<Kind3<F, R, E, A>>
+export declare function getApplicativeMonoid<F extends URIS2>(
+  F: Applicative2<F>
+): <A, E>(M: Monoid<A>) => Monoid<Kind2<F, E, A>>
+export declare function getApplicativeMonoid<F extends URIS2, E>(
+  F: Applicative2C<F, E>
+): <A>(M: Monoid<A>) => Monoid<Kind2<F, E, A>>
+export declare function getApplicativeMonoid<F extends URIS>(
+  F: Applicative1<F>
+): <A>(M: Monoid<A>) => Monoid<Kind<F, A>>
+export declare function getApplicativeMonoid<F>(F: Applicative<F>): <A>(M: Monoid<A>) => Monoid<HKT<F, A>>
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition<F, G> extends FunctorComposition<F, G> {
+  readonly of: <A>(a: A) => HKT<F, HKT<G, A>>
+  readonly ap: <A, B>(fgab: HKT<F, HKT<G, (a: A) => B>>, fga: HKT<F, HKT<G, A>>) => HKT<F, HKT<G, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeCompositionHKT1<F, G extends URIS> extends FunctorCompositionHKT1<F, G> {
+  readonly of: <A>(a: A) => HKT<F, Kind<G, A>>
+  readonly ap: <A, B>(fgab: HKT<F, Kind<G, (a: A) => B>>, fga: HKT<F, Kind<G, A>>) => HKT<F, Kind<G, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeCompositionHKT2<F, G extends URIS2> extends FunctorCompositionHKT2<F, G> {
+  readonly of: <E, A>(a: A) => HKT<F, Kind2<G, E, A>>
+  readonly ap: <E, A, B>(fgab: HKT<F, Kind2<G, E, (a: A) => B>>, fga: HKT<F, Kind2<G, E, A>>) => HKT<F, Kind2<G, E, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeCompositionHKT2C<F, G extends URIS2, E> extends FunctorCompositionHKT2C<F, G, E> {
+  readonly of: <A>(a: A) => HKT<F, Kind2<G, E, A>>
+  readonly ap: <A, B>(fgab: HKT<F, Kind2<G, E, (a: A) => B>>, fga: HKT<F, Kind2<G, E, A>>) => HKT<F, Kind2<G, E, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition11<F extends URIS, G extends URIS> extends FunctorComposition11<F, G> {
+  readonly of: <A>(a: A) => Kind<F, Kind<G, A>>
+  readonly ap: <A, B>(fgab: Kind<F, Kind<G, (a: A) => B>>, fga: Kind<F, Kind<G, A>>) => Kind<F, Kind<G, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition12<F extends URIS, G extends URIS2> extends FunctorComposition12<F, G> {
+  readonly of: <E, A>(a: A) => Kind<F, Kind2<G, E, A>>
+  readonly ap: <E, A, B>(
+    fgab: Kind<F, Kind2<G, E, (a: A) => B>>,
+    fga: Kind<F, Kind2<G, E, A>>
+  ) => Kind<F, Kind2<G, E, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition12C<F extends URIS, G extends URIS2, E> extends FunctorComposition12C<F, G, E> {
+  readonly of: <A>(a: A) => Kind<F, Kind2<G, E, A>>
+  readonly ap: <A, B>(fgab: Kind<F, Kind2<G, E, (a: A) => B>>, fga: Kind<F, Kind2<G, E, A>>) => Kind<F, Kind2<G, E, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition21<F extends URIS2, G extends URIS> extends FunctorComposition21<F, G> {
+  readonly of: <E, A>(a: A) => Kind2<F, E, Kind<G, A>>
+  readonly ap: <E, A, B>(
+    fgab: Kind2<F, E, Kind<G, (a: A) => B>>,
+    fga: Kind2<F, E, Kind<G, A>>
+  ) => Kind2<F, E, Kind<G, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition2C1<F extends URIS2, G extends URIS, E> extends FunctorComposition2C1<F, G, E> {
+  readonly of: <A>(a: A) => Kind2<F, E, Kind<G, A>>
+  readonly ap: <A, B>(fgab: Kind2<F, E, Kind<G, (a: A) => B>>, fga: Kind2<F, E, Kind<G, A>>) => Kind2<F, E, Kind<G, B>>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ApplicativeComposition22<F extends URIS2, G extends URIS2> extends FunctorComposition22<F, G> {
+  readonly of: <FE, GE, A>(a: A) => Kind2<F, FE, Kind2<G, GE, A>>
+  readonly ap: <FE, GE, A, B>(
+    fgab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>,
+    fga: 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 ApplicativeComposition22C<F extends URIS2, G extends URIS2, E> extends FunctorComposition22C<F, G, E> {
+  readonly of: <FE, A>(a: A) => Kind2<F, FE, Kind2<G, E, A>>
+  readonly ap: <FE, A, B>(
+    fgab: Kind2<F, FE, Kind2<G, E, (a: A) => B>>,
+    fga: Kind2<F, FE, Kind2<G, E, A>>
+  ) => Kind2<F, FE, Kind2<G, E, B>>
+}
+/**
+ * Use [`ap`](./Apply.ts.html#ap) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function getApplicativeComposition<F extends URIS2, G extends URIS2, E>(
+  F: Applicative2<F>,
+  G: Applicative2C<G, E>
+): ApplicativeComposition22C<F, G, E>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS2, G extends URIS2>(
+  F: Applicative2<F>,
+  G: Applicative2<G>
+): ApplicativeComposition22<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS2, G extends URIS2, E>(
+  F: Applicative2<F>,
+  G: Applicative2C<G, E>
+): ApplicativeComposition22C<F, G, E>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS2, G extends URIS>(
+  F: Applicative2<F>,
+  G: Applicative1<G>
+): ApplicativeComposition21<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS, G extends URIS2>(
+  F: Applicative1<F>,
+  G: Applicative2<G>
+): ApplicativeComposition12<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS, G extends URIS2, E>(
+  F: Applicative1<F>,
+  G: Applicative2C<G, E>
+): ApplicativeComposition12C<F, G, E>
+/** @deprecated */
+export declare function getApplicativeComposition<F extends URIS, G extends URIS>(
+  F: Applicative1<F>,
+  G: Applicative1<G>
+): ApplicativeComposition11<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F, G extends URIS2>(
+  F: Applicative<F>,
+  G: Applicative2<G>
+): ApplicativeCompositionHKT2<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F, G extends URIS2, E>(
+  F: Applicative<F>,
+  G: Applicative2C<G, E>
+): ApplicativeCompositionHKT2C<F, G, E>
+/** @deprecated */
+export declare function getApplicativeComposition<F, G extends URIS>(
+  F: Applicative<F>,
+  G: Applicative1<G>
+): ApplicativeCompositionHKT1<F, G>
+/** @deprecated */
+export declare function getApplicativeComposition<F, G>(
+  F: Applicative<F>,
+  G: Applicative<G>
+): ApplicativeComposition<F, G>