@frankieone/one-sdk 0.1.0-poc.15

package/dist/types/models/Document.d.ts

@@ -0,0 +1,112 @@
+import { TValidation, Nullable, ICloneable } from "./General";
+import { Core } from "./Core";
+declare type TFileUploadUuid = string;
+export declare type TScan = {
+    scanId: Nullable<TFileUploadUuid>;
+    fileUploadUuid?: Nullable<string>;
+    file?: Nullable<string>;
+    mimeType?: Nullable<string>;
+    side?: Nullable<string>;
+    scanCreated?: Nullable<string>;
+    scanName?: Nullable<string>;
+};
+declare type TDocumentValidation = {
+    manual: {
+        isValid: Nullable<boolean>;
+    };
+    electronic: {
+        validationReport: Nullable<Scan>;
+        isValid: Nullable<boolean>;
+    };
+};
+declare type TDocumentVerification = {
+    electronic: Nullable<boolean>;
+    manual: Nullable<boolean>;
+};
+export interface IDocumentPayload {
+    documentId: Nullable<string>;
+    verified: TDocumentVerification;
+    dateOfBirth: Nullable<string>;
+    idType: Nullable<Core["enumIdType"]>;
+    idSubType: Nullable<string>;
+    country: Nullable<string>;
+    region: Nullable<string>;
+    idNumber: Nullable<string>;
+    idExpiry: Nullable<string>;
+    gender: Nullable<Core["enumGender"]>;
+    extraData: {
+        [field: string]: Nullable<string | boolean | number>;
+    };
+    docScan: TScan[];
+    scans: TScan[];
+    validation: TDocumentValidation;
+}
+export declare class Document implements IDocumentPayload, ICloneable<Document> {
+    documentId: Nullable<string>;
+    verified: TDocumentVerification;
+    dateOfBirth: Nullable<string>;
+    idType: Nullable<Core["enumIdType"]>;
+    idSubType: Nullable<string>;
+    country: Nullable<string>;
+    region: Nullable<string>;
+    idNumber: Nullable<string>;
+    idExpiry: Nullable<string>;
+    extraData: {
+        [field: string]: Nullable<string | boolean | number>;
+    };
+    gender: Nullable<Core["enumGender"]>;
+    scans: Scan[];
+    validation: TDocumentValidation;
+    constructor();
+    constructor(d: IDocumentConstructor);
+    get docScan(): Scan[];
+    set docScan(v: Scan[]);
+    isNewDocument(): boolean;
+    getUploadedScanUuids(): string[];
+    includeUploadFile(uploadUuid: string, s: Scan): void;
+    clone(): Document;
+    toJSON(): IDocumentPayload;
+    static fromJSON(payload: IDocumentPayload): Document;
+    static default(): Document;
+}
+export declare class Scan {
+    scanId: Nullable<string>;
+    fileUploadUuid: Nullable<string>;
+    file: Nullable<string>;
+    mimeType: Nullable<string>;
+    side: Nullable<string>;
+    scanCreated: Nullable<string>;
+    scanName: Nullable<string>;
+    constructor(scan: TScan);
+    toJSON(): TScan;
+    static fromJSON(payload: TScan): Scan;
+}
+export interface IDocumentConstructor {
+    documentId: string | null;
+    verified?: {
+        electronic: TValidation;
+        manual: TValidation;
+    };
+    dateOfBirth: string | null;
+    idType: Core["enumIdType"];
+    idSubType: string | null;
+    country: string | null;
+    region: string | null;
+    idNumber: string | null;
+    idExpiry: string | null;
+    gender: Core["enumGender"] | null;
+    extraData?: {
+        [field: string]: Nullable<string | boolean | number>;
+    };
+    scans?: Scan[];
+    validation?: {
+        manual: {
+            isValid: TValidation;
+        };
+        electronic: {
+            validationReport: Scan | null;
+            isValid: TValidation;
+        };
+    };
+}
+export {};

package/dist/types/models/General.d.ts

@@ -0,0 +1,196 @@
+import { Applicant, IApplicantPayload } from "./Applicant";
+import { IDocumentPayload, Document } from "./Document";
+import { SupportingDocument, ISupportingDocumentPayload } from "./SupportingDocument";
+import { ICheckSummaryPayload, CheckSummary } from "./CheckSummary";
+import { OrganisationPayload } from "./Organisation";
+import { Admin } from "./Admin";
+import { Core } from "./Core";
+import { PartialDeep } from "type-fest";
+export declare type Nullable<T> = T | null;
+export declare type IStringOrNull = string | null;
+export declare type Dictionary<T = any> = {
+    [key: string]: T;
+};
+export declare type Kvp = (AdminKvpWithoutValue | CoreKvpWithoutValue) & {
+    kvpValue: any;
+};
+export declare type DictionaryReturnTypes<D extends Dictionary<(...args: any) => any>> = {
+    [P in keyof D]: ReturnType<D[P]>;
+};
+export declare type DeepPartial<T> = PartialDeep<T>;
+export declare interface ICloneable<T> {
+    clone(): T;
+}
+declare type AdminKvpWithoutValue = Omit<Admin["KeyValuePairObject"], "kvpValue">;
+declare type CoreKvpWithoutValue = Omit<Core["KeyValuePairObject"], "kvpValue">;
+export declare type TDOBTypeSupport = "gregorian" | "buddhist";
+export declare type DateObject = {
+    dd: IStringOrNull;
+    mm: IStringOrNull;
+    yyyy: IStringOrNull;
+};
+export declare type ExtraData = {
+    [field: string]: Nullable<string | boolean | number>;
+};
+export declare type TValidation = boolean | null;
+export declare type TValidationFieldIssues = string[];
+export declare type TValidationResult = {
+    [field: string]: TValidationFieldIssues;
+};
+export declare type TFieldIssuesTuple = [string, TValidationFieldIssues];
+export declare type TApplicantStatus = {
+    type: TStatusType | null;
+    label: string;
+    key: string;
+    action?: string;
+};
+export declare type TStatusType = "failed" | "passed" | "fail_manual" | "pass_manual" | "refer" | "wait" | "unchecked" | "archived" | "inactive";
+export declare interface IMachineCredential {
+    customerId: string;
+    customerChildId?: string | null;
+    apiKey: string;
+}
+export declare interface IUserCredential {
+    username: string;
+    password: string;
+}
+export declare type IFrankieClientCredentials = IMachineCredential | IUserCredential;
+export declare interface IApplicantInformation {
+    applicant: Applicant;
+    documents?: Document[];
+    supportingDocuments?: SupportingDocument[];
+}
+export declare interface ICreateApplicantResponse {
+    entityId: string;
+    requestId: string;
+}
+export declare type SearchOptions = {
+    reference: string;
+    entityId: string;
+};
+export declare interface IUserRole {
+    id: number;
+    role: string;
+    isHidden: boolean;
+    permissions: [];
+    createdAt: {
+        date: Date;
+    };
+}
+export declare interface ICreateUser {
+    userData: ICreateUserData;
+}
+export declare interface ICreateUserData {
+    realname: string;
+    username: string;
+    email: string;
+    roleIds: number[];
+}
+export declare interface ITriggerChecksResponse {
+    hasCreditHeaderIssue: boolean;
+    detailLevel: TDetailLevel;
+}
+export declare interface IGetExternalIdvToken {
+    token: string;
+}
+export declare type TDetailLevel = "full";
+export declare interface IGetApplicantDetailsResponse {
+    applicant: IApplicantPayload;
+    documents: IDocumentPayload[];
+    checkSummary: ICheckSummaryPayload;
+}
+export declare interface IGetApplicantInformationResponse {
+    applicant: IApplicantPayload;
+    documents: IDocumentPayload[];
+    supportingDocuments: ISupportingDocumentPayload[];
+}
+export interface ICreateIDVTokenResponse {
+    token: string;
+    applicant: IApplicantPayload;
+    documents: IDocumentPayload[];
+    checkSummary: ICheckSummaryPayload;
+    docTypesRequiredToCheck: IDocumentPayload["idType"][];
+    idvTwoDocuments: boolean;
+}
+export interface IApplicantDetails {
+    applicant: Applicant;
+    documents: Document[];
+    checkSummary: CheckSummary;
+}
+export interface IGetCommits {
+    coreApiCommitId: string;
+    adminApiCommitId: boolean;
+}
+export interface IAnalyticsData {
+    [organizationId: string]: IOrganizationAnalytics;
+}
+export declare type IOrganizationAnalytics = {
+    pass_rate: TPassRateAnalytics;
+    risk_level: TRiskLevelAnalytics;
+    issues: TIssueCount[];
+};
+export declare type TPassRateAnalytics = {
+    passed: number;
+    manually_passed: number;
+    failed: number;
+    manually_failed: number;
+    needs_attention: number;
+    unchecked: number;
+    pending: number;
+    duplicate: number;
+    archived: number;
+    inactive: number;
+};
+export declare type TRiskLevelAnalytics = {
+    high: number;
+    low: number;
+    medium: number;
+    unacceptable: number;
+    unknown: number;
+};
+export declare type TIssueCount = {
+    type: string;
+    count: number;
+};
+export declare type TEventPayload = {
+    customerId: string;
+    sessionId: string;
+    data: {
+        [field: string]: Nullable<string | boolean | number>;
+    };
+    channel: Nullable<string>;
+    version: Nullable<string>;
+    deviceType: Nullable<string>;
+    browser: Nullable<string>;
+};
+export declare type TIssueType = "warning" | "action" | "alert" | "success";
+export interface IIssue {
+    term: string;
+    type: TIssueType;
+}
+export interface IIssueAction extends IIssue {
+    type: "action";
+    extra: {
+        action: string;
+        label?: string;
+    };
+}
+export declare type TKycMethod = "electronic" | "manual";
+export interface IChangeStamp {
+    channel: ChannelString;
+    userId: string;
+    by: string;
+    timestamp: string;
+}
+export declare enum ChannelString {
+    PORTAL = "PORTAL",
+    SMART_UI = "SMART_UI",
+    API = "API"
+}
+export declare function isMachineCredential(cred: any): cred is IMachineCredential;
+export declare function isUserCredential(cred: any): cred is IUserCredential;
+export interface ICreateMachineSessionResponse {
+    organisation: OrganisationPayload;
+    [configurations: string]: any;
+}
+export {};

package/dist/types/models/Organisation.d.ts

@@ -0,0 +1,36 @@
+import { User } from "./User";
+import { Nullable } from "./General";
+export declare type OrganisationPayload = {
+    id: Nullable<number>;
+    parentId: Nullable<number>;
+    customerId: Nullable<string>;
+    customerChildId: Nullable<string>;
+    name: Nullable<string>;
+    nickName: Nullable<string>;
+    authType: Nullable<string>;
+    isRoot: Nullable<boolean>;
+    denyOldPasswordCount: Nullable<number>;
+    timezone: Nullable<string>;
+    parent: Nullable<OrganisationPayload>;
+    children: OrganisationPayload[];
+    organisations: OrganisationPayload[];
+    users: User[];
+};
+export declare class Organisation {
+    id: Nullable<number>;
+    parentId: Nullable<number>;
+    customerId: Nullable<string>;
+    customerChildId: Nullable<string>;
+    name: Nullable<string>;
+    nickName: Nullable<string>;
+    authType: Nullable<string>;
+    isRoot: Nullable<boolean>;
+    denyOldPasswordCount: Nullable<number>;
+    timezone: Nullable<string>;
+    parent: Nullable<Organisation>;
+    children: Organisation[];
+    users: User[];
+    organisations: Organisation[];
+    toJSON(): OrganisationPayload;
+    static fromJSON(payload: OrganisationPayload): Organisation;
+}

package/dist/types/models/Profile.d.ts

@@ -0,0 +1,27 @@
+export interface IProfilePayload {
+    profileType: string | null;
+    kycMethod: string;
+    countryAlpha3: string | null;
+    dob: string | null;
+    checkTypes: string[];
+}
+export declare class Profile {
+    private kycMethod;
+    private country;
+    private profileType;
+    private config;
+    private dob;
+    private _hadcodedCheckTypes;
+    constructor(profileType: string | null, kycMethod: string);
+    constructor(profileType: string | null, kycMethod: string, countryAlpha3: string | null, dob: string | null, configOrCheckType: {
+        checkTypes: string[];
+    } | any);
+    initialiseConfigOrCheckType(profileType: string | null, configOrCheckType: any): string;
+    setConfiguration(config: any): void;
+    getConfiguration(): string[];
+    getProfileType(): string;
+    get checkTypes(): string[];
+    toJSON(): IProfilePayload;
+    static fromJSON(payload: IProfilePayload): Profile;
+    static default(): Profile;
+}

package/dist/types/models/SupportingDocument.d.ts

@@ -0,0 +1,95 @@
+import { Scan, TScan } from "./Document";
+import { Nullable, ICloneable, IChangeStamp } from "./General";
+export declare enum DocumentType {
+    DRIVERS_LICENCE = "DRIVERS_LICENCE",
+    PASSPORT = "PASSPORT",
+    VISA = "VISA",
+    IMMIGRATION = "IMMIGRATION",
+    NATIONAL_ID = "NATIONAL_ID",
+    NATIONAL_HEALTH_ID = "NATIONAL_HEALTH_ID",
+    CONCESSION = "CONCESSION",
+    HEALTH_CONCESSION = "HEALTH_CONCESSION",
+    PENSION = "PENSION",
+    MILITARY_ID = "MILITARY_ID",
+    BIRTH_CERT = "BIRTH_CERT",
+    CITIZENSHIP = "CITIZENSHIP",
+    MARRIAGE_CERT = "MARRIAGE_CERT",
+    DEATH_CERT = "DEATH_CERT",
+    NAME_CHANGE = "NAME_CHANGE",
+    UTILITY_BILL = "UTILITY_BILL",
+    BANK_STATEMENT = "BANK_STATEMENT",
+    BANK_ACCOUNT = "BANK_ACCOUNT",
+    INTENT_PROOF = "INTENT_PROOF",
+    SELF_IMAGE = "SELF_IMAGE",
+    EMAIL_ADDRESS = "EMAIL_ADDRESS",
+    MSISDN = "MSISDN",
+    DEVICE = "DEVICE",
+    VEHICLE_REGISTRATION = "VEHICLE_REGISTRATION",
+    PROOF_OF_ADDRESS = "PROOF_OF_ADDRESS",
+    EXTERNAL_ADMIN = "EXTERNAL_ADMIN",
+    CHARGES = "CHARGES",
+    PRE_ASIC = "PRE_ASIC",
+    ANNUAL_RETURN = "ANNUAL_RETURN",
+    REPORT = "REPORT",
+    TRUST_DEED = "TRUST_DEED",
+    PARTNERSHIP_AGREEMENT = "PARTNERSHIP_AGREEMENT",
+    ADMIN_CHANGE = "ADMIN_CHANGE",
+    COMPANY_REPORT = "COMPANY_REPORT",
+    CHECK_RESULTS = "CHECK_RESULTS",
+    OTHER = "OTHER",
+    RENTAL_AGREEMENT = "RENTAL_AGREEMENT",
+    TAX_STATEMENT = "TAX_STATEMENT",
+    HOUSE_REGISTRATION = "HOUSE_REGISTRATION",
+    YELLOW_HOUSE_REGISTRATION = "YELLOW_HOUSE_REGISTRATION",
+    WORK_PERMIT = "WORK_PERMIT",
+    EMPLOYMENT_CERTIFICATE = "EMPLOYMENT_CERTIFICATE",
+    NOTARY_PUBLIC_ID = "NOTARY_PUBLIC_ID"
+}
+export declare enum DocumentStatus {
+    APPROVED = "APPROVED",
+    DECLINED = "DECLINED",
+    NEEDS_REVIEW = "NEEDS_REVIEW"
+}
+export declare type SupportingDocumentReference = {
+    uuid: string;
+    type: string;
+};
+export declare const ALLOWED_MIME_TYPES: string[];
+export declare const ALLOWED_MIME_TYPES_STRING: string;
+export interface ISupportingDocument {
+    id?: Nullable<string>;
+    type: DocumentType;
+    label: string;
+    file: Nullable<Scan>;
+    status?: Nullable<DocumentStatus>;
+    modified?: Nullable<IChangeStamp>;
+    reviewed?: Nullable<IChangeStamp>;
+    refer?: Nullable<SupportingDocumentReference>;
+    smartUiDocOrder?: Nullable<number>;
+}
+export interface ISupportingDocumentPayload {
+    id?: Nullable<string>;
+    type: DocumentType;
+    label: string;
+    file: Nullable<TScan>;
+    status?: Nullable<DocumentStatus>;
+    modified?: Nullable<IChangeStamp>;
+    reviewed?: Nullable<IChangeStamp>;
+    refer?: Nullable<SupportingDocumentReference>;
+    smartUiDocOrder?: Nullable<number>;
+}
+export declare class SupportingDocument implements ISupportingDocument, ICloneable<SupportingDocument> {
+    id: Nullable<string>;
+    type: DocumentType;
+    label: string;
+    file: Nullable<Scan>;
+    status: Nullable<DocumentStatus>;
+    modified: Nullable<IChangeStamp>;
+    reviewed: Nullable<IChangeStamp>;
+    refer: Nullable<SupportingDocumentReference>;
+    smartUiDocOrder: Nullable<number>;
+    constructor(payload: ISupportingDocument);
+    clone(): SupportingDocument;
+    toJSON(): ISupportingDocument;
+    static fromJSON(payload: ISupportingDocumentPayload): SupportingDocument;
+}

package/dist/types/models/User.d.ts

@@ -0,0 +1,27 @@
+export declare type UserPayload = User;
+export interface User {
+    id: number;
+    organizationId: number | null;
+    username: string;
+    password: string;
+    salt: string;
+    realname: string | null;
+    email: string;
+    isActive: boolean;
+}
+export declare type TUser = {
+    id?: number;
+    organizationId?: number | null;
+    username?: string;
+    password?: string;
+    realname?: string | null;
+    email?: string;
+    isActive?: boolean;
+    loggedAt?: Date | null;
+    createdAt?: Date;
+    updatedAt?: Date | null;
+    deletedAt?: Date | null;
+    isLocked?: boolean;
+    latestChildViewed?: string | null;
+    [field: string]: any;
+};

package/dist/types/models/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./ConfigurationReader";
+export * from "./Applicant";
+export * from "./Document";
+export * from "./CheckSummary";
+export * from "./Document";
+export * from "./SupportingDocument";
+export * from "./Address";
+export * from "./Profile";
+export * from "./Organisation";
+export * from "./General";
+export * from "./Core";
+export * from "./Admin";
+export * from "./User";
+export { default as countryData } from "./data/country.json";

package/dist/types/models/transformers/apiState.d.ts

@@ -0,0 +1,23 @@
+import { TApplicantStatus } from "../General";
+export declare const STATE_FAILED = "failed";
+export declare const STATE_PASSED = "passed";
+export declare const STATE_FAIL = "fail";
+export declare const STATE_PASS = "pass";
+export declare const STATE_MANUAL_FAILED = "fail_manual";
+export declare const STATE_MANUAL_PASSED = "pass_manual";
+export declare const STATE_NEEDS_ATTENTION = "refer";
+export declare const STATE_WAITING_ON_CUSTOMER = "wait";
+export declare const STATE_UNCHECKED = "unchecked";
+export declare enum STATE_TYPES {
+    FAILED = "failed",
+    PASSED = "passed",
+    MANUAL_FAILED = "fail_manual",
+    MANUAL_PASSED = "pass_manual",
+    NEEDS_ATTENTION = "refer",
+    WAITING_ON_CUSTOMER = "wait",
+    UNCHECKED = "unchecked",
+    ARCHIVED = "archived",
+    INACTIVE = "inactive"
+}
+export default function stateBackend(state: string): TApplicantStatus;
+export declare const sortStatus: (a: TApplicantStatus, b: TApplicantStatus) => number;

package/dist/types/models/utils/address.d.ts

@@ -0,0 +1,2 @@
+import { Address } from "../Address";
+export declare const isEmptyAddress: (address: Address) => boolean;

package/dist/types/models/utils/base64.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export declare function stringToBase64(s: string): string;
+export declare function bufferToBase64(b: Buffer): string;
+export declare function base64ToString(bs: string): string;
+export declare function bufferToString(b: Buffer): string;
+export declare function hexToByteString(hex: string): string;
+export declare function hexToBytes(hex: string): number[];
+export declare function bytesToBase64(byt: number[]): string;
+export declare function bufferToByteString(buff: Buffer): number[];
+export declare function stringToByteString(str: string): number[];

package/dist/types/models/utils/buildCycleUtils.d.ts

@@ -0,0 +1 @@
+export declare function webpackChainEnableShadowDOM(config: any): void;

package/dist/types/models/utils/constants.d.ts

@@ -0,0 +1,75 @@
+export declare const ID_TYPES: {
+    DRIVERS_LICENCE: string;
+    PASSPORT: string;
+    VISA: string;
+    MEDICARE_CARD: string;
+    IMMIGRATION: string;
+    BIRTH_CERT: string;
+    CITIZENSHIP: string;
+    NAME_CHANGE: string;
+    MARRIAGE_CERT: string;
+    ATTESTATION: string;
+    VEHICLE_REGISTRATION: string;
+    SELF_IMAGE: string;
+    OTHER: string;
+    NATIONAL_ID: string;
+    BANK_STATEMENT: string;
+};
+export declare const ID_COUNTRY_CODES: {
+    AUSTRALIA: string;
+    NEW_ZEALAND: string;
+    UNITED_KINGDOM: string;
+    INDIA: string;
+    PHILIPPINES: string;
+    CHINA: string;
+    HONG_KONG: string;
+    INDONESIA: string;
+    MALAYSIA: string;
+    SPAIN: string;
+    SWEDEN: string;
+    ITALY: string;
+    BRAZIL: string;
+    MEXICO: string;
+    RUSSIA: string;
+    TURKEY: string;
+    SINGAPORE: string;
+    SOUTH_AFRICA: string;
+    ARGENTINA: string;
+    JORDAN: string;
+    KUWAIT: string;
+    OMAN: string;
+    SAUDI_ARABIA: string;
+    EGYPT: string;
+    ROMANIA: string;
+    VIETNAM: string;
+    CAMBODIA: string;
+    DEFAULT: string;
+};
+export declare const ID_COUNTRY_OPTIONS: {
+    label: string;
+    value: string;
+}[];
+export declare const ID_SUB_TYPE: {
+    [x: string]: {
+        PAN_CARD: string;
+        EPIC_CARD: string;
+    };
+};
+export declare const CATEGORY_PRIMARY_PHOTO = "primary_photographic";
+export declare const CATEGORY_PRIMARY_NONPHOTO = "primary_nonphotographic";
+export declare const CATEGORY_SECONDARY = "secondary";
+export declare const ID_OPTIONS: ({
+    label: string;
+    value: string;
+    available: string[];
+    idSubType?: undefined;
+} | {
+    label: string;
+    value: string;
+    idSubType: string;
+    available: string[];
+})[];
+export declare const CONSENT_FLAGS: {
+    general: string[];
+    flagWhenSplitTheConsent: string[];
+};

package/dist/types/models/utils/date.d.ts

@@ -0,0 +1,5 @@
+import { DateObject, Nullable, TDOBTypeSupport } from "../General";
+export declare const transformDateToGregorian: (input: Nullable<string>, type: TDOBTypeSupport) => string;
+export declare const transformGregorianDateTo: (input: Nullable<string>, type: TDOBTypeSupport) => string;
+export declare const breakDateToObject: (input: string | null) => DateObject;
+export declare const serialiseDateObject: (obj: DateObject) => string;

package/dist/types/models/utils/getCountryDetails.d.ts

@@ -0,0 +1,9 @@
+declare type TCountryObject = {
+    label: string;
+};
+export default function getCountryDetails(code3: string): TCountryObject;
+declare type TStateObject = {
+    label: string;
+};
+export declare function getAustralianStateDetails(code3: string): TStateObject | null;
+export {};

package/dist/types/models/utils/getDocumentDetails.d.ts

@@ -0,0 +1,8 @@
+declare type TDocumentDetails = {
+    label: string;
+    value: string;
+    available?: string[];
+    excluded?: string[];
+};
+export declare function getDocumentDetails(code: string): TDocumentDetails | null;
+export {};

package/dist/types/models/utils/helper.d.ts

@@ -0,0 +1,4 @@
+export declare function checkIncludes(arr: string[], value: string | undefined | null): boolean;
+export declare const mergeObject: (defaultObj: any, targetObj: any | undefined) => any;
+export declare const mergeArray: (defaultArray: any[], targetArray: any[] | undefined) => any[];
+export declare const getNameLabel: (displayName: any) => any;

package/dist/types/models/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./base64";
+export * from "./constants";
+export * from "./getCountryDetails";
+export { default as getCountryDetails } from "./getCountryDetails";
+export * from "./getDocumentDetails";
+export * from "./helper";
+export * from "./isEmpty";
+export * from "./date";
+export * from "./address";
+export * from "./sanitiser";
+export * as buildCycleUtils from "./buildCycleUtils";

package/dist/types/models/utils/isEmpty.d.ts

@@ -0,0 +1,5 @@
+interface Options {
+    deep?: boolean;
+}
+export default function isEmpty(data: any, options?: Options): boolean;
+export {};