@nascentdigital/funnel-core 4.4.4

package/dist/services/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EventBus"), exports);
+__exportStar(require("./humanVerification"), exports);
+__exportStar(require("./leadGen"), exports);

package/dist/services/leadGen/Contact.d.ts

@@ -0,0 +1,40 @@
+export type Contact<TUserData extends Contact.UserData = Contact.UserData, TTags extends Contact.Tags = Contact.Tags> = Contact.Basic<TUserData>;
+export declare namespace Contact {
+    type Base<TUserData extends UserData, TTags extends Tags> = {
+        name: Contact.Name;
+        email: string;
+        phone?: Contact.Phone;
+        userData: TUserData;
+        tags?: TTags;
+    };
+    export type Basic<TUserData extends UserData = UserData, TTags extends Tags = Tags> = Base<TUserData, TTags> & {
+        __type: 'basic';
+    };
+    export namespace Basic {
+        function filter(contact: Contact): contact is Basic;
+    }
+    export type UserData = Record<string, string | number>;
+    export type Tags = string[];
+    export type Phone = Phone.Single | Phone.Multiple;
+    export namespace Phone {
+        type Single = string;
+        type Multiple = {
+            primary: string;
+            mobile?: string;
+            work?: string;
+        };
+        function isSingle(phone: Phone): phone is Single;
+        function isMultiple(phone: Phone): phone is Multiple;
+    }
+    export type Name = Name.Full | Name.Split;
+    export namespace Name {
+        type Full = string;
+        type Split = {
+            firstName: string;
+            lastName: string;
+        };
+        function isFull(name: Name): name is Full;
+        function isSplit(name: Name): name is Split;
+    }
+    export {};
+}

package/dist/services/leadGen/Contact.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = void 0;
+// extension
+var Contact;
+(function (Contact) {
+    let Basic;
+    (function (Basic) {
+        function filter(contact) {
+            return contact.__type === 'basic';
+        }
+        Basic.filter = filter;
+    })(Basic = Contact.Basic || (Contact.Basic = {}));
+    let Phone;
+    (function (Phone) {
+        // guard
+        function isSingle(phone) {
+            return typeof phone === 'string';
+        }
+        Phone.isSingle = isSingle;
+        function isMultiple(phone) {
+            return typeof phone === 'object';
+        }
+        Phone.isMultiple = isMultiple;
+    })(Phone = Contact.Phone || (Contact.Phone = {}));
+    let Name;
+    (function (Name) {
+        // guard
+        function isFull(name) {
+            return typeof name === 'string';
+        }
+        Name.isFull = isFull;
+        function isSplit(name) {
+            return typeof name === 'object';
+        }
+        Name.isSplit = isSplit;
+    })(Name = Contact.Name || (Contact.Name = {}));
+})(Contact || (exports.Contact = Contact = {}));

package/dist/services/leadGen/ILeadGen.d.ts

@@ -0,0 +1,16 @@
+import { Contact } from './Contact';
+export interface ILeadGen {
+    captureEmail(args: any): Promise<void>;
+    captureContact(args: ILeadGen.CaptureContactArgs): Promise<ILeadGen.CaptureContactResponse>;
+    captureLead(args: any): Promise<void>;
+}
+export declare namespace ILeadGen {
+    type CaptureContactArgs<TUserData extends Contact.UserData = Contact.UserData, TTags extends Contact.Tags = Contact.Tags> = {
+        contact: Contact<TUserData, TTags>;
+        verificationToken: string;
+    };
+    type CaptureContactResponse<TResponse extends object = object> = TResponse;
+    type Config = {
+        provider: ILeadGen;
+    };
+}

package/dist/services/leadGen/ILeadGen.js

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

package/dist/services/leadGen/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Contact';
+export * from './ILeadGen';

package/dist/services/leadGen/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Contact"), exports);
+__exportStar(require("./ILeadGen"), exports);

package/dist/types/BoxedValue.d.ts

@@ -0,0 +1,3 @@
+export type BoxedValue<T> = {
+    value: T;
+};

package/dist/types/BoxedValue.js

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

package/dist/types/Callback.d.ts

@@ -0,0 +1,9 @@
+export type Callback<TIn> = (input: TIn) => void;
+export declare namespace Callback {
+    type Never = () => never;
+    type Void = () => void;
+    type Async<TIn> = (input: TIn) => Promise<void>;
+    type AsyncVoid = () => Promise<void>;
+    type Continuation = (proceed: Void) => void;
+    type AsyncContinuation = (proceed: Void) => Promise<void>;
+}

package/dist/types/Callback.js

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

package/dist/types/DateString.d.ts

@@ -0,0 +1,35 @@
+export type DateString = `${DateString.Year}-${DateString.Month}-${DateString.Day}`;
+export declare namespace DateString {
+    type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+    type Year = `${number}`;
+    type Month = `0${Exclude<Digit, '0'>}` | '10' | '11' | '12';
+    type Day = `0${Exclude<Digit, '0'>}` | `${1 | 2}${Digit}` | '30' | '31';
+    type FormatVariant = 'iso' | 'month-scoped' | 'full';
+    const FORMAT = "yyyy-MM-dd";
+    function filter(value: string | Date | undefined): value is DateString;
+    function ensure(value: string): DateString;
+    function coerce(value: string | null | undefined): DateString | undefined;
+    function coerceToDate(value: string | null | undefined, zone?: string): Date | undefined;
+    function today(): DateString;
+    function fromDate(date: Date): DateString;
+    function yearStart(year?: number): DateString;
+    function yearEnd(year?: number): DateString;
+    function getYear(value: DateString): number;
+    function getMonth(value: DateString): number;
+    function toDate(date: DateString, zone?: string): Date;
+    function format(value: DateString, variant?: FormatVariant): string;
+    function isBefore(thisDate: DateString, thatDate: DateString): boolean;
+    function isAfter(thisDate: DateString, thatDate: DateString): boolean;
+    function min(thisDate: DateString, thatDate: DateString): DateString;
+    function max(thisDate: DateString, thatDate: DateString): DateString;
+    function addDays(value: DateString, days: number): DateString;
+    function addMonths(value: DateString, months: number): DateString;
+    function addYears(value: DateString, years: number): DateString;
+    function subDays(value: DateString, days: number): DateString;
+    function subMonths(value: DateString, months: number): DateString;
+    function subYears(value: DateString, years: number): DateString;
+    function compareAsc(lhs: DateString, rhs: DateString): number;
+    function compareDesc(lhs: DateString, rhs: DateString): number;
+    function getNetWorkDays(startDate: DateString, endDate: DateString): number;
+    function getNetDays(startDate: DateString, endDate: DateString): number;
+}

package/dist/types/DateString.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateString = void 0;
+const errors_1 = require("../errors");
+const date_fns_1 = require("date-fns");
+const date_fns_tz_1 = require("date-fns-tz");
+// extensions
+var DateString;
+(function (DateString) {
+    // constants
+    const REGEX = /([1-3]\d{3})-((0[1-9])|(1[0-2]))-((0[1-9])|([1-2]\d)|(3[0-1]))/;
+    DateString.FORMAT = 'yyyy-MM-dd';
+    // methods
+    function filter(value) {
+        return typeof value === 'string' && REGEX.test(value);
+    }
+    DateString.filter = filter;
+    function ensure(value) {
+        if (!filter(value)) {
+            throw new errors_1.ArgumentError(`Invalid date format "${value}" - expected "yyyy-MM-dd"`);
+        }
+        return value;
+    }
+    DateString.ensure = ensure;
+    function coerce(value) {
+        return value && filter(value)
+            ? value
+            : undefined;
+    }
+    DateString.coerce = coerce;
+    function coerceToDate(value, zone = 'America/Toronto') {
+        // skip if it's not a valid date string
+        if (!value || !filter(value)) {
+            return undefined;
+        }
+        // otherwise, parse date
+        else {
+            return toDate(value);
+        }
+    }
+    DateString.coerceToDate = coerceToDate;
+    function today() {
+        return fromDate(new Date());
+    }
+    DateString.today = today;
+    function fromDate(date) {
+        return (0, date_fns_1.format)(date, DateString.FORMAT);
+    }
+    DateString.fromDate = fromDate;
+    function yearStart(year) {
+        const date = year
+            ? new Date(year, 0, 1)
+            : (0, date_fns_1.startOfYear)(new Date());
+        return fromDate(date);
+    }
+    DateString.yearStart = yearStart;
+    function yearEnd(year) {
+        const date = year
+            ? new Date(year, 11, 31)
+            : (0, date_fns_1.endOfYear)(new Date());
+        return fromDate(date);
+    }
+    DateString.yearEnd = yearEnd;
+    function getYear(value) {
+        return Number.parseInt(value.substring(0, 4));
+    }
+    DateString.getYear = getYear;
+    function getMonth(value) {
+        return Number.parseInt(value.substring(5, 7));
+    }
+    DateString.getMonth = getMonth;
+    function toDate(date, zone = 'America/Toronto') {
+        return new Date((0, date_fns_tz_1.fromZonedTime)(date, zone));
+    }
+    DateString.toDate = toDate;
+    function format(value, variant = 'iso') {
+        switch (variant) {
+            case 'month-scoped':
+                return (0, date_fns_1.format)(toDate(value), 'MMM d');
+            case 'full':
+                return (0, date_fns_1.format)(toDate(value), 'MMM d, yyyy');
+            default:
+                return value;
+        }
+    }
+    DateString.format = format;
+    function isBefore(thisDate, thatDate) {
+        return compareAsc(thisDate, thatDate) < 0;
+    }
+    DateString.isBefore = isBefore;
+    function isAfter(thisDate, thatDate) {
+        return compareAsc(thisDate, thatDate) > 0;
+    }
+    DateString.isAfter = isAfter;
+    function min(thisDate, thatDate) {
+        return isBefore(thisDate, thatDate)
+            ? thisDate
+            : thatDate;
+    }
+    DateString.min = min;
+    function max(thisDate, thatDate) {
+        return isAfter(thisDate, thatDate)
+            ? thisDate
+            : thatDate;
+    }
+    DateString.max = max;
+    function addDays(value, days) {
+        // convert to date and add days
+        const date = toDate(value);
+        const nextDate = (0, date_fns_1.addDays)(date, days);
+        // return date string
+        return fromDate(nextDate);
+    }
+    DateString.addDays = addDays;
+    function addMonths(value, months) {
+        // convert to date and add days
+        const date = toDate(value);
+        const nextDate = (0, date_fns_1.addMonths)(date, months);
+        // return date string
+        return fromDate(nextDate);
+    }
+    DateString.addMonths = addMonths;
+    function addYears(value, years) {
+        // convert to date and add days
+        const date = toDate(value);
+        const nextDate = (0, date_fns_1.addYears)(date, years);
+        // return date string
+        return fromDate(nextDate);
+    }
+    DateString.addYears = addYears;
+    function subDays(value, days) {
+        // convert to date and subtract days
+        const date = toDate(value);
+        const prevDate = (0, date_fns_1.subDays)(date, days);
+        // return date string
+        return fromDate(prevDate);
+    }
+    DateString.subDays = subDays;
+    function subMonths(value, months) {
+        // convert to date and subtract months
+        const date = toDate(value);
+        const prevDate = (0, date_fns_1.subMonths)(date, months);
+        // return date string
+        return fromDate(prevDate);
+    }
+    DateString.subMonths = subMonths;
+    function subYears(value, years) {
+        // convert to date and subtract years
+        const date = toDate(value);
+        const prevDate = (0, date_fns_1.subMonths)(date, years);
+        // return date string
+        return fromDate(prevDate);
+    }
+    DateString.subYears = subYears;
+    function compareAsc(lhs, rhs) {
+        return lhs.localeCompare(rhs);
+    }
+    DateString.compareAsc = compareAsc;
+    function compareDesc(lhs, rhs) {
+        return compareAsc(lhs, rhs) * -1;
+    }
+    DateString.compareDesc = compareDesc;
+    /* Calculates the net work days including the startDate and the endDate */
+    function getNetWorkDays(startDate, endDate) {
+        return (0, date_fns_1.differenceInBusinessDays)((0, date_fns_1.addDays)(toDate(endDate), 1), toDate(startDate));
+    }
+    DateString.getNetWorkDays = getNetWorkDays;
+    function getNetDays(startDate, endDate) {
+        return (0, date_fns_1.differenceInDays)((0, date_fns_1.addDays)(toDate(endDate), 1), toDate(startDate));
+    }
+    DateString.getNetDays = getNetDays;
+})(DateString || (exports.DateString = DateString = {}));

package/dist/types/FilterConditionally.d.ts

@@ -0,0 +1,3 @@
+export type FilterConditionally<T, U> = {
+    [K in keyof T]: T[K] extends U ? K : never;
+}[keyof T];

package/dist/types/FilterConditionally.js

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

package/dist/types/MaybeConditionalValue.d.ts

@@ -0,0 +1,8 @@
+export type MaybeConditionalValue<TCondition extends MaybeConditionalValue.Condition, TValue> = TValue | {
+    [K in TCondition]: TValue;
+};
+export declare namespace MaybeConditionalValue {
+    type Condition = string | number;
+    type ConditionalValues = any;
+    function isConditional<TCondition extends Condition, TValue>(maybeValue: MaybeConditionalValue<TCondition, TValue>): maybeValue is ConditionalValues;
+}

package/dist/types/MaybeConditionalValue.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaybeConditionalValue = void 0;
+// extension
+var MaybeConditionalValue;
+(function (MaybeConditionalValue) {
+    // guard
+    function isConditional(maybeValue) {
+        return false;
+    }
+    MaybeConditionalValue.isConditional = isConditional;
+})(MaybeConditionalValue || (exports.MaybeConditionalValue = MaybeConditionalValue = {}));

package/dist/types/Ordinal.d.ts

@@ -0,0 +1,17 @@
+import { LexoRank } from 'lexorank';
+import { Tagged } from 'type-fest';
+export declare class Ordinal {
+    private readonly _rank;
+    constructor(rankOrOrder?: LexoRank | Ordinal.Id);
+    get order(): Ordinal.Id;
+    get prev(): Ordinal;
+    get next(): Ordinal;
+    between(ordinal: Ordinal): Ordinal;
+    compareTo(ordinal: Ordinal): number;
+    static from(rankOrOrder: LexoRank | Ordinal.Id): Ordinal;
+    static new(): Ordinal;
+    static compare(lhs: Ordinal, rhs: Ordinal): number;
+}
+export declare namespace Ordinal {
+    type Id = Tagged<string, 'Ordinal'>;
+}

package/dist/types/Ordinal.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ordinal = void 0;
+const lexorank_1 = require("lexorank");
+// class
+class Ordinal {
+    constructor(rankOrOrder) {
+        // initialize instance variables
+        this._rank = typeof rankOrOrder === 'string'
+            ? lexorank_1.LexoRank.parse(rankOrOrder)
+            : rankOrOrder !== null && rankOrOrder !== void 0 ? rankOrOrder : lexorank_1.LexoRank.middle();
+    }
+    get order() {
+        return this._rank.toString();
+    }
+    get prev() {
+        return new Ordinal(this._rank.genPrev());
+    }
+    get next() {
+        return new Ordinal(this._rank.genNext());
+    }
+    between(ordinal) {
+        return new Ordinal(this._rank.between(ordinal._rank));
+    }
+    compareTo(ordinal) {
+        return this._rank.compareTo(ordinal._rank);
+    }
+    static from(rankOrOrder) {
+        return new Ordinal(rankOrOrder);
+    }
+    static new() {
+        return new Ordinal();
+    }
+    static compare(lhs, rhs) {
+        return lhs.compareTo(rhs);
+    }
+}
+exports.Ordinal = Ordinal;

package/dist/types/OverridableStringUnion.d.ts

@@ -0,0 +1,2 @@
+import { FilterConditionally } from './FilterConditionally';
+export type OverridableStringUnion<T extends string | number | symbol, U = {}> = FilterConditionally<U, true> | Exclude<T, FilterConditionally<U, false>>;

package/dist/types/OverridableStringUnion.js

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

package/dist/types/PartialBy.d.ts

@@ -0,0 +1 @@
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/types/PartialBy.js

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

package/dist/types/PickData.d.ts

@@ -0,0 +1,6 @@
+export type PickData<T> = Pick<T, PickData.Keys<T>>;
+export declare namespace PickData {
+    type Keys<T> = {
+        [K in keyof T]: T[K] extends Function ? never : K;
+    }[keyof T];
+}

package/dist/types/PickData.js

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

package/dist/types/Provider.d.ts

@@ -0,0 +1,4 @@
+export type Provider<TOut> = () => TOut;
+export declare namespace Provider {
+    type Async<TOut> = Provider<Promise<TOut>>;
+}

package/dist/types/Provider.js

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

package/dist/types/RequiredBy.d.ts

@@ -0,0 +1 @@
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

package/dist/types/RequiredBy.js

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

package/dist/types/Result.d.ts

@@ -0,0 +1,16 @@
+import type { IsometricError } from '../errors';
+export type Result<T = any> = Result.Pending | Result.Success<T> | Result.Failure;
+export declare namespace Result {
+    type Pending = {
+        __type: 'pending';
+    };
+    type Success<T> = {
+        __type: 'success';
+        result: T;
+    };
+    type Failure = {
+        __type: 'failure';
+        error: IsometricError;
+    };
+    type Completion<T> = Success<T> | Failure;
+}

package/dist/types/Result.js

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

package/dist/types/Timestamp.d.ts

@@ -0,0 +1,17 @@
+import { Tagged } from 'type-fest';
+export type Timestamp = [Timestamp.TimeInMs, Timestamp.Timezone];
+export declare namespace Timestamp {
+    type TimeInMs = number;
+    type Timezone = Tagged<string, 'funnel.Timestamp.Timezone'>;
+    namespace Timezone {
+        const fallback: Timezone;
+    }
+    type Hour = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23;
+    function filter(value: any): value is Timestamp;
+    function coerce(value: any): Timestamp | undefined;
+    function coerceToDate(value: any): Date | undefined;
+    function toDate(value: Timestamp): Date;
+    function fromDate(time: Date | number, timeZone: Timezone): Timestamp;
+    function isBefore(thisTimestamp: Timestamp, thatTimestamp: Timestamp): boolean;
+    function isAfter(thisTimestamp: Timestamp, thatTimestamp: Timestamp): boolean;
+}

package/dist/types/Timestamp.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = void 0;
+const date_fns_1 = require("date-fns");
+const date_fns_tz_1 = require("date-fns-tz");
+// extensions
+var Timestamp;
+(function (Timestamp) {
+    let Timezone;
+    (function (Timezone) {
+        Timezone.fallback = 'EST';
+    })(Timezone = Timestamp.Timezone || (Timestamp.Timezone = {}));
+    // methods
+    function filter(value) {
+        return Array.isArray(value)
+            && value.length === 2
+            && typeof value[0] === 'number'
+            && typeof value[1] === 'string';
+    }
+    Timestamp.filter = filter;
+    function coerce(value) {
+        return filter(value) ? value : undefined;
+    }
+    Timestamp.coerce = coerce;
+    function coerceToDate(value) {
+        // skip if it's not a valid date string
+        if (!value || !filter(value)) {
+            return undefined;
+        }
+        // otherwise, parse date
+        else {
+            return toDate(value);
+        }
+    }
+    Timestamp.coerceToDate = coerceToDate;
+    function toDate(value) {
+        const [time, timeZone] = value;
+        return (0, date_fns_tz_1.toZonedTime)(time, timeZone);
+    }
+    Timestamp.toDate = toDate;
+    function fromDate(time, timeZone) {
+        return [(0, date_fns_tz_1.fromZonedTime)(time, timeZone).getTime(), timeZone];
+    }
+    Timestamp.fromDate = fromDate;
+    function isBefore(thisTimestamp, thatTimestamp) {
+        const thisDate = toDate(thisTimestamp);
+        const thatDate = toDate(thatTimestamp);
+        return (0, date_fns_1.compareAsc)(thisDate, thatDate) < 0;
+    }
+    Timestamp.isBefore = isBefore;
+    function isAfter(thisTimestamp, thatTimestamp) {
+        const thisDate = toDate(thisTimestamp);
+        const thatDate = toDate(thatTimestamp);
+        return (0, date_fns_1.compareAsc)(thisDate, thatDate) > 0;
+    }
+    Timestamp.isAfter = isAfter;
+})(Timestamp || (exports.Timestamp = Timestamp = {}));

package/dist/types/Transform.d.ts

@@ -0,0 +1,4 @@
+export type Transform<TIn, TOut> = (input: TIn) => TOut;
+export declare namespace Transform {
+    type Async<TIn, TOut> = Transform<TIn, Promise<TOut>>;
+}

package/dist/types/Transform.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export * from './BoxedValue';
+export * from './Callback';
+export * from './DateString';
+export * from './FilterConditionally';
+export * from './MaybeConditionalValue';
+export * from './Ordinal';
+export * from './OverridableStringUnion';
+export * from './PartialBy';
+export * from './PickData';
+export * from './Provider';
+export * from './RequiredBy';
+export * from './Result';
+export * from './Timestamp';
+export * from './Transform';