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

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

@@ -0,0 +1,141 @@
+/**
+ * @since 2.0.0
+ */
+import { Applicative2C } from './Applicative'
+import { Apply2C } from './Apply'
+import { Chain2C } from './Chain'
+import { Functor2 } from './Functor'
+import { Monad2C } from './Monad'
+import { Monoid } from './Monoid'
+import { Pointed2C } from './Pointed'
+import { Semigroup } from './Semigroup'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Writer<W, A> {
+  (): [A, W]
+}
+/**
+ * Appends a value to the accumulator
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const tell: <W>(w: W) => Writer<W, void>
+/**
+ * Modifies the result to include the changes to the accumulator
+ *
+ * @since 2.0.0
+ */
+export declare const listen: <W, A>(fa: Writer<W, A>) => Writer<W, [A, W]>
+/**
+ * Applies the returned function to the accumulator
+ *
+ * @since 2.0.0
+ */
+export declare const pass: <W, A>(fa: Writer<W, [A, (w: W) => W]>) => Writer<W, A>
+/**
+ * Projects a value from modifications made to the accumulator during an action
+ *
+ * @since 2.0.0
+ */
+export declare const listens: <W, B>(f: (w: W) => B) => <A>(fa: Writer<W, A>) => Writer<W, [A, B]>
+/**
+ * Modify the final accumulator value by applying a function
+ *
+ * @since 2.0.0
+ */
+export declare const censor: <W>(f: (w: W) => W) => <A>(fa: Writer<W, A>) => Writer<W, A>
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Writer<E, A>) => Writer<E, B>
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export declare const URI = 'Writer'
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind2<E, A> {
+    readonly [URI]: Writer<E, A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getPointed: <W>(M: Monoid<W>) => Pointed2C<URI, W>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getApply: <W>(S: Semigroup<W>) => Apply2C<URI, W>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getApplicative: <W>(M: Monoid<W>) => Applicative2C<URI, W>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare function getChain<W>(S: Semigroup<W>): Chain2C<URI, W>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare function getMonad<W>(M: Monoid<W>): Monad2C<URI, W>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Functor: Functor2<URI>
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export declare const flap: <A>(
+  a: A
+) => <E, B>(fab: import('./HKT').Kind2<'Writer', E, (a: A) => B>) => import('./HKT').Kind2<'Writer', E, B>
+/**
+ * @since 2.8.0
+ */
+export declare const evaluate: <W, A>(fa: Writer<W, A>) => A
+/**
+ * @since 2.8.0
+ */
+export declare const execute: <W, A>(fa: Writer<W, A>) => W
+/**
+ * Use [`evaluate`](#evaluate) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const evalWriter: <W, A>(fa: Writer<W, A>) => A
+/**
+ * Use [`execute`](#execute) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const execWriter: <W, A>(fa: Writer<W, A>) => W
+/**
+ * Use [`Functor`](#functor) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const writer: Functor2<URI>

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

@@ -0,0 +1,192 @@
+import { pipe } from './function';
+import { flap as flap_ } from './Functor';
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Appends a value to the accumulator
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var tell = function (w) { return function () { return [undefined, w]; }; };
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * Modifies the result to include the changes to the accumulator
+ *
+ * @since 2.0.0
+ */
+export var listen = function (fa) { return function () {
+    var _a = fa(), a = _a[0], w = _a[1];
+    return [[a, w], w];
+}; };
+/**
+ * Applies the returned function to the accumulator
+ *
+ * @since 2.0.0
+ */
+export var pass = function (fa) { return function () {
+    var _a = fa(), _b = _a[0], a = _b[0], f = _b[1], w = _a[1];
+    return [a, f(w)];
+}; };
+/**
+ * Projects a value from modifications made to the accumulator during an action
+ *
+ * @since 2.0.0
+ */
+export var listens = function (f) { return function (fa) { return function () {
+    var _a = fa(), a = _a[0], w = _a[1];
+    return [[a, f(w)], w];
+}; }; };
+/**
+ * Modify the final accumulator value by applying a function
+ *
+ * @since 2.0.0
+ */
+export var censor = function (f) { return function (fa) { return function () {
+    var _a = fa(), a = _a[0], w = _a[1];
+    return [a, f(w)];
+}; }; };
+/* istanbul ignore next */
+var _map = function (fa, f) { return pipe(fa, map(f)); };
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export var map = function (f) { return function (fa) { return function () {
+    var _a = fa(), a = _a[0], w = _a[1];
+    return [f(a), w];
+}; }; };
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export var URI = 'Writer';
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var getPointed = function (M) { return ({
+    URI: URI,
+    _E: undefined,
+    of: function (a) { return function () { return [a, M.empty]; }; }
+}); };
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var getApply = function (S) { return ({
+    URI: URI,
+    _E: undefined,
+    map: _map,
+    ap: function (fab, fa) { return function () {
+        var _a = fab(), f = _a[0], w1 = _a[1];
+        var _b = fa(), a = _b[0], w2 = _b[1];
+        return [f(a), S.concat(w1, w2)];
+    }; }
+}); };
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var getApplicative = function (M) {
+    var A = getApply(M);
+    var P = getPointed(M);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: _map,
+        ap: A.ap,
+        of: P.of
+    };
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export function getChain(S) {
+    var A = getApply(S);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: _map,
+        ap: A.ap,
+        chain: function (fa, f) { return function () {
+            var _a = fa(), a = _a[0], w1 = _a[1];
+            var _b = f(a)(), b = _b[0], w2 = _b[1];
+            return [b, S.concat(w1, w2)];
+        }; }
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getMonad(M) {
+    var A = getApplicative(M);
+    var C = getChain(M);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: _map,
+        ap: A.ap,
+        of: A.of,
+        chain: C.chain
+    };
+}
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Functor = {
+    URI: URI,
+    map: _map
+};
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export var flap = /*#__PURE__*/ flap_(Functor);
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+export var evaluate = function (fa) { return fa()[0]; };
+/**
+ * @since 2.8.0
+ */
+export var execute = function (fa) { return fa()[1]; };
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`evaluate`](#evaluate) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var evalWriter = function (fa) { return fa()[0]; };
+/**
+ * Use [`execute`](#execute) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var execWriter = function (fa) { return fa()[1]; };
+/**
+ * Use [`Functor`](#functor) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var writer = Functor;

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

@@ -0,0 +1,147 @@
+/**
+ * @since 2.4.0
+ */
+import { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
+import { Monad, Monad1, Monad2, Monad2C, Monad3 } from './Monad'
+import { Monoid } from './Monoid'
+/**
+ * @category model
+ * @since 2.4.0
+ */
+export interface WriterT<M, W, A> {
+  (): HKT<M, [A, W]>
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterM<M> {
+  readonly map: <W, A, B>(fa: WriterT<M, W, A>, f: (a: A) => B) => WriterT<M, W, B>
+  readonly evalWriter: <W, A>(fa: WriterT<M, W, A>) => HKT<M, A>
+  readonly execWriter: <W, A>(fa: WriterT<M, W, A>) => HKT<M, W>
+  readonly tell: <W>(w: W) => WriterT<M, W, void>
+  readonly listen: <W, A>(fa: WriterT<M, W, A>) => WriterT<M, W, [A, W]>
+  readonly pass: <W, A>(fa: WriterT<M, W, [A, (w: W) => W]>) => WriterT<M, W, A>
+  readonly listens: <W, A, B>(fa: WriterT<M, W, A>, f: (w: W) => B) => WriterT<M, W, [A, B]>
+  readonly censor: <W, A>(fa: WriterT<M, W, A>, f: (w: W) => W) => WriterT<M, W, A>
+  readonly getMonad: <W>(M: Monoid<W>) => {
+    readonly _E: W
+    readonly map: <A, B>(ma: WriterT<M, W, A>, f: (a: A) => B) => WriterT<M, W, B>
+    readonly of: <A>(a: A) => WriterT<M, W, A>
+    readonly ap: <A, B>(mab: WriterT<M, W, (a: A) => B>, ma: WriterT<M, W, A>) => WriterT<M, W, B>
+    readonly chain: <A, B>(ma: WriterT<M, W, A>, f: (a: A) => WriterT<M, W, B>) => WriterT<M, W, B>
+  }
+}
+/**
+ * @category model
+ * @since 2.4.0
+ */
+export interface WriterT1<M extends URIS, W, A> {
+  (): Kind<M, [A, W]>
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterM1<M extends URIS> {
+  readonly map: <W, A, B>(fa: WriterT1<M, W, A>, f: (a: A) => B) => WriterT1<M, W, B>
+  readonly evalWriter: <W, A>(fa: WriterT1<M, W, A>) => Kind<M, A>
+  readonly execWriter: <W, A>(fa: WriterT1<M, W, A>) => Kind<M, W>
+  readonly tell: <W>(w: W) => WriterT1<M, W, void>
+  readonly listen: <W, A>(fa: WriterT1<M, W, A>) => WriterT1<M, W, [A, W]>
+  readonly pass: <W, A>(fa: WriterT1<M, W, [A, (w: W) => W]>) => WriterT1<M, W, A>
+  readonly listens: <W, A, B>(fa: WriterT1<M, W, A>, f: (w: W) => B) => WriterT1<M, W, [A, B]>
+  readonly censor: <W, A>(fa: WriterT1<M, W, A>, f: (w: W) => W) => WriterT1<M, W, A>
+  readonly getMonad: <W>(M: Monoid<W>) => {
+    readonly _E: W
+    readonly map: <A, B>(ma: WriterT1<M, W, A>, f: (a: A) => B) => WriterT1<M, W, B>
+    readonly of: <A>(a: A) => WriterT1<M, W, A>
+    readonly ap: <A, B>(mab: WriterT1<M, W, (a: A) => B>, ma: WriterT1<M, W, A>) => WriterT1<M, W, B>
+    readonly chain: <A, B>(ma: WriterT1<M, W, A>, f: (a: A) => WriterT1<M, W, B>) => WriterT1<M, W, B>
+  }
+}
+/**
+ * @category model
+ * @since 2.4.0
+ */
+export interface WriterT2<M extends URIS2, E, W, A> {
+  (): Kind2<M, E, [A, W]>
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterM2<M extends URIS2> {
+  readonly map: <E, W, A, B>(fa: WriterT2<M, E, W, A>, f: (a: A) => B) => WriterT2<M, E, W, B>
+  readonly evalWriter: <E, W, A>(fa: WriterT2<M, E, W, A>) => Kind2<M, E, A>
+  readonly execWriter: <E, W, A>(fa: WriterT2<M, E, W, A>) => Kind2<M, E, W>
+  readonly tell: <E, W>(w: W) => WriterT2<M, E, W, void>
+  readonly listen: <E, W, A>(fa: WriterT2<M, E, W, A>) => WriterT2<M, E, W, [A, W]>
+  readonly pass: <E, W, A>(fa: WriterT2<M, E, W, [A, (w: W) => W]>) => WriterT2<M, E, W, A>
+  readonly listens: <E, W, A, B>(fa: WriterT2<M, E, W, A>, f: (w: W) => B) => WriterT2<M, E, W, [A, B]>
+  readonly censor: <E, W, A>(fa: WriterT2<M, E, W, A>, f: (w: W) => W) => WriterT2<M, E, W, A>
+  readonly getMonad: <W>(M: Monoid<W>) => {
+    readonly _E: W
+    readonly map: <E, A, B>(ma: WriterT2<M, E, W, A>, f: (a: A) => B) => WriterT2<M, E, W, B>
+    readonly of: <E, A>(a: A) => WriterT2<M, E, W, A>
+    readonly ap: <E, A, B>(mab: WriterT2<M, E, W, (a: A) => B>, ma: WriterT2<M, E, W, A>) => WriterT2<M, E, W, B>
+    readonly chain: <E, A, B>(ma: WriterT2<M, E, W, A>, f: (a: A) => WriterT2<M, E, W, B>) => WriterT2<M, E, W, B>
+  }
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterM2C<M extends URIS2, E> {
+  readonly map: <W, A, B>(fa: WriterT2<M, E, W, A>, f: (a: A) => B) => WriterT2<M, E, W, B>
+  readonly evalWriter: <W, A>(fa: WriterT2<M, E, W, A>) => Kind2<M, E, A>
+  readonly execWriter: <W, A>(fa: WriterT2<M, E, W, A>) => Kind2<M, E, W>
+  readonly tell: <W>(w: W) => WriterT2<M, E, W, void>
+  readonly listen: <W, A>(fa: WriterT2<M, E, W, A>) => WriterT2<M, E, W, [A, W]>
+  readonly pass: <W, A>(fa: WriterT2<M, E, W, [A, (w: W) => W]>) => WriterT2<M, E, W, A>
+  readonly listens: <W, A, B>(fa: WriterT2<M, E, W, A>, f: (w: W) => B) => WriterT2<M, E, W, [A, B]>
+  readonly censor: <W, A>(fa: WriterT2<M, E, W, A>, f: (w: W) => W) => WriterT2<M, E, W, A>
+  readonly getMonad: <W>(M: Monoid<W>) => {
+    readonly _E: W
+    readonly map: <A, B>(ma: WriterT2<M, E, W, A>, f: (a: A) => B) => WriterT2<M, E, W, B>
+    readonly of: <A>(a: A) => WriterT2<M, E, W, A>
+    readonly ap: <A, B>(mab: WriterT2<M, E, W, (a: A) => B>, ma: WriterT2<M, E, W, A>) => WriterT2<M, E, W, B>
+    readonly chain: <A, B>(ma: WriterT2<M, E, W, A>, f: (a: A) => WriterT2<M, E, W, B>) => WriterT2<M, E, W, B>
+  }
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterT3<M extends URIS3, R, E, W, A> {
+  (): Kind3<M, R, E, [A, W]>
+}
+/**
+ * @since 2.4.0
+ */
+export interface WriterM3<M extends URIS3> {
+  readonly map: <R, E, W, A, B>(fa: WriterT3<M, R, E, W, A>, f: (a: A) => B) => WriterT3<M, R, E, W, B>
+  readonly evalWriter: <R, E, W, A>(fa: WriterT3<M, R, E, W, A>) => Kind3<M, R, E, A>
+  readonly execWriter: <R, E, W, A>(fa: WriterT3<M, R, E, W, A>) => Kind3<M, R, E, W>
+  readonly tell: <R, E, W>(w: W) => WriterT3<M, R, E, W, void>
+  readonly listen: <R, E, W, A>(fa: WriterT3<M, R, E, W, A>) => WriterT3<M, R, E, W, [A, W]>
+  readonly pass: <R, E, W, A>(fa: WriterT3<M, R, E, W, [A, (w: W) => W]>) => WriterT3<M, R, E, W, A>
+  readonly listens: <R, E, W, A, B>(fa: WriterT3<M, R, E, W, A>, f: (w: W) => B) => WriterT3<M, R, E, W, [A, B]>
+  readonly censor: <R, E, W, A>(fa: WriterT3<M, R, E, W, A>, f: (w: W) => W) => WriterT3<M, R, E, W, A>
+  readonly getMonad: <W>(M: Monoid<W>) => {
+    readonly _E: W
+    readonly map: <R, E, A, B>(ma: WriterT3<M, R, E, W, A>, f: (a: A) => B) => WriterT3<M, R, E, W, B>
+    readonly of: <R, E, A>(a: A) => WriterT3<M, R, E, W, A>
+    readonly ap: <R, E, A, B>(
+      mab: WriterT3<M, R, E, W, (a: A) => B>,
+      ma: WriterT3<M, R, E, W, A>
+    ) => WriterT3<M, R, E, W, B>
+    readonly chain: <R, E, A, B>(
+      ma: WriterT3<M, R, E, W, A>,
+      f: (a: A) => WriterT3<M, R, E, W, B>
+    ) => WriterT3<M, R, E, W, B>
+  }
+}
+/**
+ * @since 2.4.0
+ */
+export declare function getWriterM<M extends URIS3>(M: Monad3<M>): WriterM3<M>
+export declare function getWriterM<M extends URIS2>(M: Monad2<M>): WriterM2<M>
+export declare function getWriterM<M extends URIS2, E>(M: Monad2C<M, E>): WriterM2C<M, E>
+export declare function getWriterM<M extends URIS>(M: Monad1<M>): WriterM1<M>
+export declare function getWriterM<M>(M: Monad<M>): WriterM<M>

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

@@ -0,0 +1,59 @@
+export function getWriterM(M) {
+    var map = function (fa, f) {
+        return function () {
+            return M.map(fa(), function (_a) {
+                var a = _a[0], w = _a[1];
+                return [f(a), w];
+            });
+        };
+    };
+    return {
+        map: map,
+        evalWriter: function (fa) { return M.map(fa(), function (_a) {
+            var a = _a[0];
+            return a;
+        }); },
+        execWriter: function (fa) { return M.map(fa(), function (_a) {
+            var _ = _a[0], w = _a[1];
+            return w;
+        }); },
+        tell: function (w) { return function () { return M.of([undefined, w]); }; },
+        listen: function (fa) { return function () { return M.map(fa(), function (_a) {
+            var a = _a[0], w = _a[1];
+            return [[a, w], w];
+        }); }; },
+        pass: function (fa) { return function () { return M.map(fa(), function (_a) {
+            var _b = _a[0], a = _b[0], f = _b[1], w = _a[1];
+            return [a, f(w)];
+        }); }; },
+        listens: function (fa, f) { return function () { return M.map(fa(), function (_a) {
+            var a = _a[0], w = _a[1];
+            return [[a, f(w)], w];
+        }); }; },
+        censor: function (fa, f) { return function () { return M.map(fa(), function (_a) {
+            var a = _a[0], w = _a[1];
+            return [a, f(w)];
+        }); }; },
+        getMonad: function (W) {
+            return {
+                _E: undefined,
+                map: map,
+                of: function (a) { return function () { return M.of([a, W.empty]); }; },
+                ap: function (mab, ma) { return function () { return M.chain(mab(), function (_a) {
+                    var f = _a[0], w1 = _a[1];
+                    return M.map(ma(), function (_a) {
+                        var a = _a[0], w2 = _a[1];
+                        return [f(a), W.concat(w1, w2)];
+                    });
+                }); }; },
+                chain: function (ma, f) { return function () { return M.chain(ma(), function (_a) {
+                    var a = _a[0], w1 = _a[1];
+                    return M.map(f(a)(), function (_a) {
+                        var b = _a[0], w2 = _a[1];
+                        return [b, W.concat(w1, w2)];
+                    });
+                }); }; }
+            };
+        }
+    };
+}

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

@@ -0,0 +1,83 @@
+/**
+ * @since 2.11.0
+ */
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Pointed, Pointed1, Pointed2, Pointed2C, Pointed3, Pointed3C, Pointed4 } from './Pointed'
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero<F> {
+  readonly URI: F
+  readonly zero: <A>() => HKT<F, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero1<F extends URIS> {
+  readonly URI: F
+  readonly zero: <A>() => Kind<F, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero2<F extends URIS2> {
+  readonly URI: F
+  readonly zero: <E, A>() => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero2C<F extends URIS2, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly zero: <A>() => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero3<F extends URIS3> {
+  readonly URI: F
+  readonly zero: <R, E, A>() => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero3C<F extends URIS3, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly zero: <R, A>() => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.11.0
+ */
+export interface Zero4<F extends URIS4> {
+  readonly URI: F
+  readonly zero: <S, R, E, A>() => Kind4<F, S, R, E, A>
+}
+/**
+ * @category do notation
+ * @since 2.11.0
+ */
+export declare function guard<F extends URIS4>(
+  F: Zero4<F>,
+  P: Pointed4<F>
+): <S, R, E>(b: boolean) => Kind4<F, S, R, E, void>
+export declare function guard<F extends URIS3>(F: Zero3<F>, P: Pointed3<F>): <R, E>(b: boolean) => Kind3<F, R, E, void>
+export declare function guard<F extends URIS3, E>(
+  F: Zero3C<F, E>,
+  P: Pointed3C<F, E>
+): <R>(b: boolean) => Kind3<F, R, E, void>
+export declare function guard<F extends URIS2>(F: Zero2<F>, P: Pointed2<F>): <E>(b: boolean) => Kind2<F, E, void>
+export declare function guard<F extends URIS2, E>(
+  F: Zero2C<F, E>,
+  P: Pointed2C<F, E>
+): (b: boolean) => Kind2<F, E, void>
+export declare function guard<F extends URIS>(F: Zero1<F>, P: Pointed1<F>): (b: boolean) => Kind<F, void>
+export declare function guard<F>(F: Zero<F>, P: Pointed<F>): (b: boolean) => HKT<F, void>

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

@@ -0,0 +1,3 @@
+export function guard(F, P) {
+    return function (b) { return (b ? P.of(undefined) : F.zero()); };
+}