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

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

@@ -0,0 +1,19 @@
+/**
+ * A meet-semilattice (or lower semilattice) is a semilattice whose operation is called `meet`, and which can be thought
+ * of as a greatest lower bound.
+ *
+ * A `MeetSemilattice` must satisfy the following laws:
+ *
+ * - Associativity: `a ∧ (b ∧ c) <-> (a ∧ b) ∧ c`
+ * - Commutativity: `a ∧ b <-> b ∧ a`
+ * - Idempotency:   `a ∧ a <-> a`
+ *
+ * @since 2.0.0
+ */
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MeetSemilattice<A> {
+  readonly meet: (x: A, y: A) => A
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * A meet-semilattice (or lower semilattice) is a semilattice whose operation is called `meet`, and which can be thought
+ * of as a greatest lower bound.
+ *
+ * A `MeetSemilattice` must satisfy the following laws:
+ *
+ * - Associativity: `a ∧ (b ∧ c) <-> (a ∧ b) ∧ c`
+ * - Commutativity: `a ∧ b <-> b ∧ a`
+ * - Idempotency:   `a ∧ a <-> a`
+ *
+ * @since 2.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,61 @@
+/**
+ * The `Monad` type class combines the operations of the `Chain` and
+ * `Applicative` type classes. Therefore, `Monad` instances represent type
+ * constructors which support sequential composition, and also lifting of
+ * functions of arbitrary arity.
+ *
+ * Instances must satisfy the following laws in addition to the `Applicative` and `Chain` laws:
+ *
+ * 1. Left identity: `M.chain(M.of(a), f) <-> f(a)`
+ * 2. Right identity: `M.chain(fa, M.of) <-> fa`
+ *
+ * Note. `Functor`'s `map` can be derived: `A.map = (fa, f) => A.chain(fa, a => A.of(f(a)))`
+ *
+ * @since 2.0.0
+ */
+import {
+  Applicative,
+  Applicative1,
+  Applicative2,
+  Applicative2C,
+  Applicative3,
+  Applicative3C,
+  Applicative4
+} from './Applicative'
+import { Chain, Chain1, Chain2, Chain2C, Chain3, Chain3C, Chain4 } from './Chain'
+import { URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad<F> extends Applicative<F>, Chain<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad1<F extends URIS> extends Applicative1<F>, Chain1<F> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad2<M extends URIS2> extends Applicative2<M>, Chain2<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad2C<M extends URIS2, L> extends Applicative2C<M, L>, Chain2C<M, L> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad3<M extends URIS3> extends Applicative3<M>, Chain3<M> {}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Monad3C<M extends URIS3, E> extends Applicative3C<M, E>, Chain3C<M, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monad4<M extends URIS4> extends Applicative4<M>, Chain4<M> {}

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * Lift a computation from the `IO` monad
+ *
+ * @since 2.0.0
+ */
+import { FromIO, FromIO1, FromIO2, FromIO2C, FromIO3, FromIO3C, FromIO4 } from './FromIO'
+import { URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Monad, Monad1, Monad2, Monad2C, Monad3, Monad3C, Monad4 } from './Monad'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadIO<M> extends Monad<M>, FromIO<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadIO1<M extends URIS> extends Monad1<M>, FromIO1<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadIO2<M extends URIS2> extends Monad2<M>, FromIO2<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadIO2C<M extends URIS2, E> extends Monad2C<M, E>, FromIO2C<M, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadIO3<M extends URIS3> extends Monad3<M>, FromIO3<M> {}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface MonadIO3C<M extends URIS3, E> extends Monad3C<M, E>, FromIO3C<M, E> {}
+/**
+ * @category model
+ * @since 2.4.4
+ */
+export interface MonadIO4<M extends URIS4> extends Monad4<M>, FromIO4<M> {}

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * Lift a computation from the `Task` monad
+ *
+ * @since 2.0.0
+ */
+import { FromTask, FromTask1, FromTask2, FromTask2C, FromTask3, FromTask3C, FromTask4 } from './FromTask'
+import { URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { MonadIO, MonadIO1, MonadIO2, MonadIO2C, MonadIO3, MonadIO3C, MonadIO4 } from './MonadIO'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadTask<M> extends MonadIO<M>, FromTask<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadTask1<M extends URIS> extends MonadIO1<M>, FromTask1<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadTask2<M extends URIS2> extends MonadIO2<M>, FromTask2<M> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadTask2C<M extends URIS2, E> extends MonadIO2C<M, E>, FromTask2C<M, E> {}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadTask3<M extends URIS3> extends MonadIO3<M>, FromTask3<M> {}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface MonadTask3C<M extends URIS3, E> extends MonadIO3C<M, E>, FromTask3C<M, E> {}
+/**
+ * @category model
+ * @since 2.4.4
+ */
+export interface MonadTask4<M extends URIS4> extends MonadIO4<M>, FromTask4<M> {}

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

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

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

@@ -0,0 +1,61 @@
+/**
+ * The `MonadThrow` type class represents those monads which support errors via
+ * `throwError`, where `throwError(e)` halts, yielding the error `e`.
+ *
+ * Laws:
+ *
+ * - Left zero: `M.chain(M.throwError(e), f) = M.throwError(e)`
+ *
+ * @since 2.0.0
+ */
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Monad, Monad1, Monad2, Monad2C, Monad3, Monad3C, Monad4 } from './Monad'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow<M> extends Monad<M> {
+  readonly throwError: <E, A>(e: E) => HKT<M, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow1<M extends URIS> extends Monad1<M> {
+  readonly throwError: <E, A>(e: E) => Kind<M, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow2<M extends URIS2> extends Monad2<M> {
+  readonly throwError: <E, A>(e: E) => Kind2<M, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow2C<M extends URIS2, E> extends Monad2C<M, E> {
+  readonly throwError: <A>(e: E) => Kind2<M, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow3<M extends URIS3> extends Monad3<M> {
+  readonly throwError: <R, E, A>(e: E) => Kind3<M, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface MonadThrow3C<M extends URIS3, E> extends Monad3C<M, E> {
+  readonly throwError: <R, A>(e: E) => Kind3<M, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface MonadThrow4<M extends URIS4> extends Monad4<M> {
+  readonly throwError: <S, R, E, A>(e: E) => Kind4<M, S, R, E, A>
+}

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

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

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

@@ -0,0 +1,268 @@
+/**
+ * `Monoid` extends the power of `Semigroup` by providing an additional `empty` value.
+ *
+ * ```ts
+ * interface Semigroup<A> {
+ *   readonly concat: (x: A, y: A) => A
+ * }
+ *
+ * interface Monoid<A> extends Semigroup<A> {
+ *   readonly empty: A
+ * }
+ * ```
+ *
+ * This `empty` value should be an identity for the `concat` operation, which means the following equalities hold for any choice of `x`.
+ *
+ * ```ts
+ * concat(x, empty) = concat(empty, x) = x
+ * ```
+ *
+ * Many types that form a `Semigroup` also form a `Monoid`, such as `number`s (with `0`) and `string`s (with `''`).
+ *
+ * ```ts
+ * import { Monoid } from 'fp-ts/Monoid'
+ *
+ * const monoidString: Monoid<string> = {
+ *   concat: (x, y) => x + y,
+ *   empty: ''
+ * }
+ * ```
+ *
+ * *Adapted from https://typelevel.org/cats*
+ *
+ * @since 2.0.0
+ */
+import { Bounded } from './Bounded'
+import { Endomorphism } from './Endomorphism'
+import { ReadonlyRecord } from './ReadonlyRecord'
+import * as Se from './Semigroup'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Monoid<A> extends Se.Semigroup<A> {
+  readonly empty: A
+}
+/**
+ * Get a monoid where `concat` will return the minimum, based on the provided bounded order.
+ *
+ * The `empty` value is the `top` value.
+ *
+ * @example
+ * import * as N from 'fp-ts/number'
+ * import * as M from 'fp-ts/Monoid'
+ *
+ * const M1 = M.min(N.Bounded)
+ *
+ * assert.deepStrictEqual(M1.concat(1, 2), 1)
+ *
+ * @category constructors
+ * @since 2.10.0
+ */
+export declare const min: <A>(B: Bounded<A>) => Monoid<A>
+/**
+ * Get a monoid where `concat` will return the maximum, based on the provided bounded order.
+ *
+ * The `empty` value is the `bottom` value.
+ *
+ * @example
+ * import * as N from 'fp-ts/number'
+ * import * as M from 'fp-ts/Monoid'
+ *
+ * const M1 = M.max(N.Bounded)
+ *
+ * assert.deepStrictEqual(M1.concat(1, 2), 2)
+ *
+ * @category constructors
+ * @since 2.10.0
+ */
+export declare const max: <A>(B: Bounded<A>) => Monoid<A>
+/**
+ * The dual of a `Monoid`, obtained by swapping the arguments of `concat`.
+ *
+ * @example
+ * import { reverse } from 'fp-ts/Monoid'
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(reverse(S.Monoid).concat('a', 'b'), 'ba')
+ *
+ * @since 2.10.0
+ */
+export declare const reverse: <A>(M: Monoid<A>) => Monoid<A>
+/**
+ * Given a struct of monoids returns a monoid for the struct.
+ *
+ * @example
+ * import { struct } from 'fp-ts/Monoid'
+ * import * as N from 'fp-ts/number'
+ *
+ * interface Point {
+ *   readonly x: number
+ *   readonly y: number
+ * }
+ *
+ * const M = struct<Point>({
+ *   x: N.MonoidSum,
+ *   y: N.MonoidSum
+ * })
+ *
+ * assert.deepStrictEqual(M.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })
+ *
+ * @since 2.10.0
+ */
+export declare const struct: <A>(monoids: { [K in keyof A]: Monoid<A[K]> }) => Monoid<{ readonly [K in keyof A]: A[K] }>
+/**
+ * Given a tuple of monoids returns a monoid for the tuple.
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Monoid'
+ * import * as B from 'fp-ts/boolean'
+ * import * as N from 'fp-ts/number'
+ * import * as S from 'fp-ts/string'
+ *
+ * const M1 = tuple(S.Monoid, N.MonoidSum)
+ * assert.deepStrictEqual(M1.concat(['a', 1], ['b', 2]), ['ab', 3])
+ *
+ * const M2 = tuple(S.Monoid, N.MonoidSum, B.MonoidAll)
+ * assert.deepStrictEqual(M2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])
+ *
+ * @since 2.10.0
+ */
+export declare const tuple: <A extends ReadonlyArray<unknown>>(
+  ...monoids: { [K in keyof A]: Monoid<A[K]> }
+) => Monoid<Readonly<A>>
+/**
+ * Given a sequence of `as`, concat them and return the total.
+ *
+ * If `as` is empty, return the monoid `empty` value.
+ *
+ * @example
+ * import { concatAll } from 'fp-ts/Monoid'
+ * import * as N from 'fp-ts/number'
+ *
+ * assert.deepStrictEqual(concatAll(N.MonoidSum)([1, 2, 3]), 6)
+ * assert.deepStrictEqual(concatAll(N.MonoidSum)([]), 0)
+ *
+ * @since 2.10.0
+ */
+export declare const concatAll: <A>(M: Monoid<A>) => (as: ReadonlyArray<A>) => A
+/**
+ * Use [`Monoid`](./void.ts.html#monoid) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidVoid: Monoid<void>
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getTupleMonoid: <T extends ReadonlyArray<Monoid<any>>>(
+  ...monoids: T
+) => Monoid<{
+  [K in keyof T]: T[K] extends Se.Semigroup<infer A> ? A : never
+}>
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getStructMonoid: <O extends ReadonlyRecord<string, any>>(monoids: {
+  [K in keyof O]: Monoid<O[K]>
+}) => Monoid<O>
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getDualMonoid: <A>(M: Monoid<A>) => Monoid<A>
+/**
+ * Use [`max`](#max) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getJoinMonoid: <A>(B: Bounded<A>) => Monoid<A>
+/**
+ * Use [`min`](#min) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getMeetMonoid: <A>(B: Bounded<A>) => Monoid<A>
+/**
+ * Use [`concatAll`](#concatall) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const fold: <A>(M: Monoid<A>) => (as: ReadonlyArray<A>) => A
+/**
+ * Use [`MonoidAll`](./boolean.ts.html#monoidall) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidAll: Monoid<boolean>
+/**
+ * Use [`MonoidAny`](./boolean.ts.html#monoidany) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidAny: Monoid<boolean>
+/**
+ * Use [`getMonoid`](./function.ts.html#getmonoid) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFunctionMonoid: <M>(M: Monoid<M>) => <A = never>() => Monoid<(a: A) => M>
+/**
+ * Use [`getEndomorphismMonoid`](./function.ts.html#getendomorphismmonoid) instead.
+ *
+ * **Note**. The execution order in [`getEndomorphismMonoid`](./function.ts.html#getendomorphismmonoid) is reversed.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getEndomorphismMonoid: <A = never>() => Monoid<Endomorphism<A>>
+/**
+ * Use [`Monoid`](./string.ts.html#monoid) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidString: Monoid<string>
+/**
+ * Use [`MonoidSum`](./number.ts.html#monoidsum) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidSum: Monoid<number>
+/**
+ * Use [`MonoidProduct`](./number.ts.html#monoidproduct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const monoidProduct: Monoid<number>