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

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

@@ -0,0 +1,60 @@
+/**
+ * @since 2.0.0
+ */
+import { HKT2, Kind2, Kind3, Kind4, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bifunctor<F> {
+  readonly URI: F
+  readonly bimap: <E, A, G, B>(fea: HKT2<F, E, A>, f: (e: E) => G, g: (a: A) => B) => HKT2<F, G, B>
+  readonly mapLeft: <E, A, G>(fea: HKT2<F, E, A>, f: (e: E) => G) => HKT2<F, G, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bifunctor2<F extends URIS2> {
+  readonly URI: F
+  readonly bimap: <E, A, G, B>(fea: Kind2<F, E, A>, f: (e: E) => G, g: (a: A) => B) => Kind2<F, G, B>
+  readonly mapLeft: <E, A, G>(fea: Kind2<F, E, A>, f: (e: E) => G) => Kind2<F, G, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bifunctor2C<F extends URIS2, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly bimap: <A, G, B>(fea: Kind2<F, E, A>, f: (e: E) => G, g: (a: A) => B) => Kind2<F, G, B>
+  readonly mapLeft: <A, M>(fea: Kind2<F, E, A>, f: (e: E) => M) => Kind2<F, M, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bifunctor3<F extends URIS3> {
+  readonly URI: F
+  readonly bimap: <R, E, A, G, B>(fea: Kind3<F, R, E, A>, f: (e: E) => G, g: (a: A) => B) => Kind3<F, R, G, B>
+  readonly mapLeft: <R, E, A, G>(fea: Kind3<F, R, E, A>, f: (e: E) => G) => Kind3<F, R, G, A>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Bifunctor3C<F extends URIS3, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly bimap: <R, A, G, B>(fea: Kind3<F, R, E, A>, f: (e: E) => G, g: (a: A) => B) => Kind3<F, R, G, B>
+  readonly mapLeft: <R, A, G>(fea: Kind3<F, R, E, A>, f: (e: E) => G) => Kind3<F, R, G, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bifunctor4<F extends URIS4> {
+  readonly URI: F
+  readonly bimap: <S, R, E, A, G, B>(fea: Kind4<F, S, R, E, A>, f: (e: E) => G, g: (a: A) => B) => Kind4<F, S, R, G, B>
+  readonly mapLeft: <S, R, E, A, G>(fea: Kind4<F, S, R, E, A>, f: (e: E) => G) => Kind4<F, S, R, G, A>
+}

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

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

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

@@ -0,0 +1,43 @@
+import { HeytingAlgebra } from './HeytingAlgebra'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface BooleanAlgebra<A> extends HeytingAlgebra<A> {}
+/**
+ * Every boolean algebras has a dual algebra, which involves reversing one/zero as well as join/meet.
+ *
+ * @since 2.10.0
+ */
+export declare const reverse: <A>(B: BooleanAlgebra<A>) => BooleanAlgebra<A>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const booleanAlgebraVoid: BooleanAlgebra<void>
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getDualBooleanAlgebra: <A>(B: BooleanAlgebra<A>) => BooleanAlgebra<A>
+/**
+ * Use [`BooleanAlgebra`](./boolean.ts.html#booleanalgebra) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const booleanAlgebraBoolean: BooleanAlgebra<boolean>
+/**
+ * Use [`getBooleanAlgebra`](./function.ts.html#getbooleanalgebra) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFunctionBooleanAlgebra: <B>(
+  B: BooleanAlgebra<B>
+) => <A = never>() => BooleanAlgebra<(a: A) => B>

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionBooleanAlgebra = exports.booleanAlgebraBoolean = exports.getDualBooleanAlgebra = exports.booleanAlgebraVoid = exports.reverse = void 0;
+/**
+ * Boolean algebras are Heyting algebras with the additional constraint that the law of the excluded middle is true
+ * (equivalently, double-negation is true).
+ *
+ * Instances should satisfy the following laws in addition to the `HeytingAlgebra` laws:
+ *
+ * - Excluded middle: `a ∨ ¬a <-> 1`
+ *
+ * Boolean algebras generalize classical logic: one is equivalent to "true" and zero is equivalent to "false".
+ *
+ * @since 2.0.0
+ */
+var function_1 = require("./function");
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * Every boolean algebras has a dual algebra, which involves reversing one/zero as well as join/meet.
+ *
+ * @since 2.10.0
+ */
+var reverse = function (B) { return ({
+    meet: function (x, y) { return B.join(x, y); },
+    join: function (x, y) { return B.meet(x, y); },
+    zero: B.one,
+    one: B.zero,
+    implies: function (x, y) { return B.join(B.not(x), y); },
+    not: B.not
+}); };
+exports.reverse = reverse;
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+exports.booleanAlgebraVoid = {
+    meet: function () { return undefined; },
+    join: function () { return undefined; },
+    zero: undefined,
+    one: undefined,
+    implies: function () { return undefined; },
+    not: function () { return undefined; }
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getDualBooleanAlgebra = exports.reverse;
+/**
+ * Use [`BooleanAlgebra`](./boolean.ts.html#booleanalgebra) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.booleanAlgebraBoolean = {
+    meet: function (x, y) { return x && y; },
+    join: function (x, y) { return x || y; },
+    zero: false,
+    one: true,
+    implies: function (x, y) { return !x || y; },
+    not: function (x) { return !x; }
+};
+/**
+ * Use [`getBooleanAlgebra`](./function.ts.html#getbooleanalgebra) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getFunctionBooleanAlgebra = function_1.getBooleanAlgebra;

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

@@ -0,0 +1,41 @@
+/**
+ * The `Bounded` type class represents totally ordered types that have an upper and lower boundary.
+ *
+ * Instances should satisfy the following law in addition to the `Ord` laws:
+ *
+ * - Bounded: `bottom <= a <= top`
+ *
+ * @since 2.0.0
+ */
+import * as O from './Ord'
+import Ord = O.Ord
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Bounded<A> extends Ord<A> {
+  readonly top: A
+  readonly bottom: A
+}
+/**
+ * Clamp a value between bottom and top values.
+ *
+ * @category utils
+ * @since 2.12.0
+ */
+export declare const clamp: <A>(B: Bounded<A>) => (a: A) => A
+/**
+ * Reverses the Ord of a bound and swaps top and bottom values.
+ *
+ * @category utils
+ * @since 2.12.0
+ */
+export declare const reverse: <A>(B: Bounded<A>) => Bounded<A>
+/**
+ * Use [`Bounded`](./number.ts.html#bounded) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const boundedNumber: Bounded<number>

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

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boundedNumber = exports.reverse = exports.clamp = void 0;
+/**
+ * The `Bounded` type class represents totally ordered types that have an upper and lower boundary.
+ *
+ * Instances should satisfy the following law in addition to the `Ord` laws:
+ *
+ * - Bounded: `bottom <= a <= top`
+ *
+ * @since 2.0.0
+ */
+var O = __importStar(require("./Ord"));
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Clamp a value between bottom and top values.
+ *
+ * @category utils
+ * @since 2.12.0
+ */
+var clamp = function (B) { return O.clamp(B)(B.bottom, B.top); };
+exports.clamp = clamp;
+/**
+ * Reverses the Ord of a bound and swaps top and bottom values.
+ *
+ * @category utils
+ * @since 2.12.0
+ */
+var reverse = function (B) {
+    var R = O.reverse(B);
+    return {
+        equals: R.equals,
+        compare: R.compare,
+        top: B.bottom,
+        bottom: B.top
+    };
+};
+exports.reverse = reverse;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`Bounded`](./number.ts.html#bounded) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.boundedNumber = {
+    equals: O.ordNumber.equals,
+    compare: O.ordNumber.compare,
+    top: Infinity,
+    bottom: -Infinity
+};

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

@@ -0,0 +1,20 @@
+/**
+ * A `BoundedDistributiveLattice` is a lattice that is both bounded and distributive
+ *
+ * @since 2.0.0
+ */
+import { BoundedLattice } from './BoundedLattice'
+import { DistributiveLattice } from './DistributiveLattice'
+import { Ord } from './Ord'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface BoundedDistributiveLattice<A> extends BoundedLattice<A>, DistributiveLattice<A> {}
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare function getMinMaxBoundedDistributiveLattice<A>(
+  O: Ord<A>
+): (min: A, max: A) => BoundedDistributiveLattice<A>

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinMaxBoundedDistributiveLattice = getMinMaxBoundedDistributiveLattice;
+var DistributiveLattice_1 = require("./DistributiveLattice");
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+function getMinMaxBoundedDistributiveLattice(O) {
+    var L = (0, DistributiveLattice_1.getMinMaxDistributiveLattice)(O);
+    return function (min, max) { return ({
+        join: L.join,
+        meet: L.meet,
+        zero: min,
+        one: max
+    }); };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * A `BoundedJoinSemilattice` must satisfy the following laws in addition to `JoinSemilattice` laws:
+ *
+ * - `a ∨ 0 <-> a`
+ *
+ * @since 2.0.0
+ */
+import { JoinSemilattice } from './JoinSemilattice'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface BoundedJoinSemilattice<A> extends JoinSemilattice<A> {
+  readonly zero: A
+}

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * A `BoundedLattice` must satisfy the following in addition to `BoundedMeetSemilattice` and `BoundedJoinSemilattice` laws:
+ *
+ * - Absorption law for meet: `a ∧ (a ∨ b) <-> a`
+ * - Absorption law for join: `a ∨ (a ∧ b) <-> a`
+ *
+ * @since 2.0.0
+ */
+import { BoundedJoinSemilattice } from './BoundedJoinSemilattice'
+import { BoundedMeetSemilattice } from './BoundedMeetSemilattice'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface BoundedLattice<A> extends BoundedJoinSemilattice<A>, BoundedMeetSemilattice<A> {}

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * A `BoundedMeetSemilattice` must satisfy the following laws in addition to `MeetSemilattice` laws:
+ *
+ * - `a ∧ 1 <-> a`
+ *
+ * @since 2.0.0
+ */
+import { MeetSemilattice } from './MeetSemilattice'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface BoundedMeetSemilattice<A> extends MeetSemilattice<A> {
+  readonly one: A
+}

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * @since 2.0.0
+ */
+import { HKT2, Kind2, Kind3, Kind4, URIS2, URIS3, URIS4 } from './HKT'
+import { Semigroupoid, Semigroupoid2, Semigroupoid3, Semigroupoid4 } from './Semigroupoid'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Category<F> extends Semigroupoid<F> {
+  readonly id: <A>() => HKT2<F, A, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Category2<F extends URIS2> extends Semigroupoid2<F> {
+  readonly id: <A>() => Kind2<F, A, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Category3<F extends URIS3> extends Semigroupoid3<F> {
+  readonly id: <R, A>() => Kind3<F, R, A, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Category4<F extends URIS4> extends Semigroupoid4<F> {
+  readonly id: <S, R, A>() => Kind4<F, S, R, A, A>
+}

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

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

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

@@ -0,0 +1,172 @@
+/**
+ * The `Chain` type class extends the `Apply` type class with a `chain` operation which composes computations in
+ * sequence, using the return value of one computation to determine the next computation.
+ *
+ * Instances must satisfy the following law in addition to the `Apply` laws:
+ *
+ * 1. Associativity: `F.chain(F.chain(fa, afb), bfc) <-> F.chain(fa, a => F.chain(afb(a), bfc))`
+ *
+ * Note. `Apply`'s `ap` can be derived: `(fab, fa) => F.chain(fab, f => F.map(fa, f))`
+ *
+ * @since 2.0.0
+ */
+import { Apply, Apply1, Apply2, Apply2C, Apply3, Apply3C, Apply4 } from './Apply'
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain<F> extends Apply<F> {
+  readonly chain: <A, B>(fa: HKT<F, A>, f: (a: A) => HKT<F, B>) => HKT<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain1<F extends URIS> extends Apply1<F> {
+  readonly chain: <A, B>(fa: Kind<F, A>, f: (a: A) => Kind<F, B>) => Kind<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain2<F extends URIS2> extends Apply2<F> {
+  readonly chain: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => Kind2<F, E, B>) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain2C<F extends URIS2, E> extends Apply2C<F, E> {
+  readonly chain: <A, B>(fa: Kind2<F, E, A>, f: (a: A) => Kind2<F, E, B>) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain3<F extends URIS3> extends Apply3<F> {
+  readonly chain: <R, E, A, B>(fa: Kind3<F, R, E, A>, f: (a: A) => Kind3<F, R, E, B>) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Chain3C<F extends URIS3, E> extends Apply3C<F, E> {
+  readonly chain: <R, A, B>(fa: Kind3<F, R, E, A>, f: (a: A) => Kind3<F, R, E, B>) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Chain4<F extends URIS4> extends Apply4<F> {
+  readonly chain: <S, R, E, A, B>(fa: Kind4<F, S, R, E, A>, f: (a: A) => Kind4<F, S, R, E, B>) => Kind4<F, S, R, E, B>
+}
+/**
+ * @since 2.10.0
+ */
+export declare function chainFirst<M extends URIS4>(
+  M: Chain4<M>
+): <A, S, R, E, _>(f: (a: A) => Kind4<M, S, R, E, _>) => (first: Kind4<M, S, R, E, A>) => Kind4<M, S, R, E, A>
+export declare function chainFirst<M extends URIS3>(
+  M: Chain3<M>
+): <A, R, E, _>(f: (a: A) => Kind3<M, R, E, _>) => (first: Kind3<M, R, E, A>) => Kind3<M, R, E, A>
+export declare function chainFirst<M extends URIS3, E>(
+  M: Chain3C<M, E>
+): <A, R, _>(f: (a: A) => Kind3<M, R, E, _>) => (first: Kind3<M, R, E, A>) => Kind3<M, R, E, A>
+export declare function chainFirst<M extends URIS2>(
+  M: Chain2<M>
+): <A, E, _>(f: (a: A) => Kind2<M, E, _>) => (first: Kind2<M, E, A>) => Kind2<M, E, A>
+export declare function chainFirst<M extends URIS2, E>(
+  M: Chain2C<M, E>
+): <A, _>(f: (a: A) => Kind2<M, E, _>) => (first: Kind2<M, E, A>) => Kind2<M, E, A>
+export declare function chainFirst<M extends URIS>(
+  M: Chain1<M>
+): <A, _>(f: (a: A) => Kind<M, _>) => (first: Kind<M, A>) => Kind<M, A>
+export declare function chainFirst<M>(M: Chain<M>): <A, _>(f: (a: A) => HKT<M, _>) => (first: HKT<M, A>) => HKT<M, A>
+/**
+ * @since 2.10.0
+ */
+export declare function bind<M extends URIS4>(
+  M: Chain4<M>
+): <N extends string, A, S, R, E, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind4<M, S, R, E, B>
+) => (ma: Kind4<M, S, R, E, A>) => Kind4<
+  M,
+  S,
+  R,
+  E,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M extends URIS3>(
+  M: Chain3<M>
+): <N extends string, A, R, E, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind3<M, R, E, B>
+) => (ma: Kind3<M, R, E, A>) => Kind3<
+  M,
+  R,
+  E,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M extends URIS3, E>(
+  M: Chain3C<M, E>
+): <N extends string, A, R, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind3<M, R, E, B>
+) => (ma: Kind3<M, R, E, A>) => Kind3<
+  M,
+  R,
+  E,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M extends URIS2>(
+  M: Chain2<M>
+): <N extends string, A, E, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind2<M, E, B>
+) => (ma: Kind2<M, E, A>) => Kind2<
+  M,
+  E,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M extends URIS2, E>(
+  M: Chain2C<M, E>
+): <N extends string, A, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind2<M, E, B>
+) => (ma: Kind2<M, E, A>) => Kind2<
+  M,
+  E,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M extends URIS>(
+  M: Chain1<M>
+): <N extends string, A, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Kind<M, B>
+) => (ma: Kind<M, A>) => Kind<
+  M,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>
+export declare function bind<M>(M: Chain<M>): <N extends string, A, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => HKT<M, B>
+) => (ma: HKT<M, A>) => HKT<
+  M,
+  {
+    readonly [K in keyof A | N]: K extends keyof A ? A[K] : B
+  }
+>

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainFirst = chainFirst;
+exports.tap = tap;
+exports.bind = bind;
+function chainFirst(M) {
+    var tapM = tap(M);
+    return function (f) { return function (first) { return tapM(first, f); }; };
+}
+/** @internal */
+function tap(M) {
+    return function (first, f) { return M.chain(first, function (a) { return M.map(f(a), function () { return a; }); }); };
+}
+function bind(M) {
+    return function (name, f) { return function (ma) { return M.chain(ma, function (a) { return M.map(f(a), function (b) {
+        var _a;
+        return Object.assign({}, a, (_a = {}, _a[name] = b, _a));
+    }); }); }; };
+}