@tap-payments/auth-jsconnect 2.11.15-development → 2.11.17-development

package/build/api/firebase.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { ENDPOINT_PATHS } from '../constants';
+import instance from './axios';
+import translationEN from '../assets/locales/en.json';
+import translationAR from '../assets/locales/ar.json';
+var getLocale = function (disableLocale) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (disableLocale)
+                    return [2, Promise.resolve(null)];
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4, instance.get("".concat(ENDPOINT_PATHS.FIREBASE_URL))];
+            case 2:
+                data = (_a.sent()).data;
+                return [2, data];
+            case 3:
+                error_1 = _a.sent();
+                return [2, {
+                        default: {
+                            en: {
+                                translation: translationEN
+                            },
+                            ar: {
+                                translation: translationAR
+                            }
+                        }
+                    }];
+            case 4: return [2];
+        }
+    });
+}); };
+var firebaseService = {
+    getLocale: getLocale
+};
+export { firebaseService };

package/build/api/index.d.ts

@@ -0,0 +1,176 @@
+import axiosInstance, { setAxiosGlobalHeaders, removeAxiosGlobalHeaders, getAxiosHeaders } from './axios';
+import { ValidateOperatorBody, ConfirmBody } from './operator';
+import { CreateAuthBody, VerifyAuthBody, CreatePasswordBody, VerifyOperationAuthBody, ResetPasswordVerifyAuthBody, VerifyAuthExpressOTPBody, ConfigBody, CreateNafathAuthBody, CreateKYCAuthBody } from './auth';
+import { UpdateLeadBody, LeadVerifyBody, CreateLeadBody, LeadOTPVerifyBody, LeadIdentityUpdateBody, ExpressLeadVerifyBody } from './lead';
+import { CheckEmailBody, CheckBrandBody } from './availabilityServices';
+import { EntityInfoBody, EntityBankUpdateBody, BankDocumentInfo, UpdateEntityBody, UpdateEntityActivityBody, UpdateEntityCapitalBody, UpdateEntityAOAFileBody, RemoveEntityActivity, MerchantListBody, CreateEntityBody } from './entity';
+import { CreateAccountBody, ExpressCreateAccountBody } from './account';
+import { DataElementBody } from './data';
+import { BrandListBody, UpdateBrandBody, UpdateIndividualBody, GetIndividualListBody, UpdateIndividualWithTypeBody, UpdateMultipleIndividualBody } from './individual';
+import { UpdateBoardBody, RequestEmailBody } from './board';
+import { GetUserListBody, GetUserListSegmentBody } from './user';
+import { RemoveBrandActivity } from './brand';
+import { UploadFileBody } from './file';
+import { DocumentUpdateBody, DocumentInfo, DocumentBody } from './document';
+import { InitBody } from './init';
+import { GenerateAuthLinkNewTerminalProps, UnlinkTerminalDeviceProps, LinkTerminalDeviceProps } from './terminal';
+declare const API: {
+    locationService: {
+        getIP: () => Promise<any>;
+        getAddress: (countryCode: string) => Promise<any>;
+    };
+    operatorService: {
+        validateOperator: (body: ValidateOperatorBody) => Promise<any>;
+        confirm: (data: ConfirmBody) => Promise<any>;
+    };
+    countryService: {
+        getCountries: (disableCountries?: boolean | undefined) => Promise<any> | {
+            list: never[];
+        };
+        getCities: (data: import("./country").GetCitiesBody) => Promise<any>;
+        getCurrency: (countryCode: string) => Promise<any>;
+    };
+    authService: {
+        createAuth: (data: CreateAuthBody | CreateKYCAuthBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        verifyAuth: (data: VerifyAuthBody | VerifyOperationAuthBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        createPassword: (data: CreatePasswordBody) => Promise<any>;
+        verifyExpressAuth: (data: VerifyAuthExpressOTPBody) => Promise<any>;
+        getVerifyAuth: (token: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        getTokenVerify: (token: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        createAuthKitNID: (data: CreateAuthBody) => Promise<any>;
+        createExpressAuth: (data: CreateAuthBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        verifyExpressLeadIdentity: (data: VerifyAuthExpressOTPBody) => Promise<any>;
+        createExpressLeadIdentityAuth: (data: CreateAuthBody) => Promise<any>;
+        getVerifyExpressAuth: (token: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        getExpressTokenVerify: ({ token, leadId }: import("./auth").getExpressTokenVerifyParams, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        generateConfigToken: (body: ConfigBody) => Promise<any>;
+    };
+    leadService: {
+        createLead: (data: CreateLeadBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        updateLead: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
+        retrieveLead: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+        getLeadById: (leadId: string) => Promise<any>;
+        verifyLeadToken: (data: LeadVerifyBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        verifyToken: (data: LeadVerifyBody) => Promise<any>;
+        verifyLeadOTP: (data: LeadOTPVerifyBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        verifyTokenOTP: (data: LeadOTPVerifyBody) => Promise<any>;
+        retrieveEntityList: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+        retrieveLeadIdentity: (leadId: string) => Promise<any>;
+        updateLeadExpress: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
+        verifyExpressLeadToken: (data: ExpressLeadVerifyBody) => Promise<any>;
+        createVerifyTokenByBoardId: (data: import("./lead").CreateVerifyTokenBody) => Promise<any>;
+    };
+    entityService: {
+        createEntityInfo: ({ id, ...data }: EntityInfoBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        updateEntityInfo: ({ id, ...data }: EntityInfoBody) => Promise<any>;
+        createBankAccount: (data: EntityBankUpdateBody) => Promise<any>;
+        retrieveBankAccount: (id: string) => Promise<any>;
+        retrieveEntityInfo: (entity_id: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        updateIndividualInfo: ({ id, ...data }: EntityInfoBody) => Promise<any>;
+        retrieveEntity: (entity_id: string) => Promise<any>;
+        updateEntity: ({ id, ...data }: UpdateEntityBody) => Promise<any>;
+        updateEntityActivity: ({ id, ...data }: UpdateEntityActivityBody) => Promise<any>;
+        retrieveEntityType: () => Promise<any>;
+        updateEntityCapital: ({ id, ...data }: UpdateEntityCapitalBody) => Promise<any>;
+        updateEntityAOAFile: ({ id, ...data }: UpdateEntityAOAFileBody) => Promise<any>;
+        retrieveAllEntities: (id: string) => Promise<any>;
+        removeEntityActivities: ({ id, ...data }: RemoveEntityActivity) => Promise<any>;
+        getEntityListUsingIndividualId: (individualId: string) => Promise<any>;
+        getMerchantListUsingEntityId: (data: MerchantListBody) => Promise<any>;
+        getTerminalListUsingMerchantId: (merchantId: string) => Promise<any>;
+        createEntity: (data: CreateEntityBody) => Promise<any>;
+    };
+    availabilityServices: {
+        checkEmail: (data: CheckEmailBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        checkBrand: (data: CheckBrandBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        checkIbanBank: (data: import("./availabilityServices").CheckIBanBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    firebaseService: {
+        getLocale: (disableLocale?: boolean | undefined) => Promise<any>;
+    };
+    accountService: {
+        createAccount: (data: CreateAccountBody) => Promise<any>;
+        expressCreateAccount: (data: ExpressCreateAccountBody) => Promise<any>;
+        checkAccountAvailability: (individualId: string) => Promise<any>;
+        checkAccountAvailabilityStatus: (individualId: string) => Promise<any>;
+        checkMigrationStatus: (jobId: string) => Promise<any>;
+    };
+    dataService: {
+        getChannelsOfServices: (data: {
+            page: number;
+        }) => Promise<any>;
+        getBrandOperations: (data: {
+            page: number;
+            country_code: string[];
+        }) => Promise<any>;
+        getSourceOfIncome: (data: {
+            page: number;
+        }) => Promise<any>;
+        getMonthlyIncome: (data: {
+            page: number;
+            country_code: string[];
+        }) => Promise<any>;
+        getOccupation: (data: {
+            page: number;
+        }) => Promise<any>;
+        getSegments: (data: {
+            page: number;
+            limit: number;
+        }) => Promise<any>;
+        getTeamSize: (data: {
+            page: number;
+        }) => Promise<any>;
+        getActivities: (config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        getActivitiesIsIc: () => Promise<any>;
+    };
+    individualService: {
+        retrieveIndividualInfo: (id: string) => Promise<any>;
+        retrieveIndividual: (id: string, type: string) => Promise<any>;
+        updateIndividual: ({ id, type, ...data }: UpdateIndividualWithTypeBody) => Promise<any>;
+        getIndividualList: (data: GetIndividualListBody) => Promise<any>;
+        updateMultipleIndividual: (data: UpdateMultipleIndividualBody) => Promise<any>;
+    };
+    boardService: {
+        retrieveBoard: (id: string) => Promise<any>;
+        updateBoard: ({ id, ...data }: UpdateBoardBody) => Promise<any>;
+        retrieveBoardInfo: ({ id, infoId }: import("./board").RetrieveBoardInfoBody) => Promise<any>;
+        updateBoardInfo: ({ id, infoId, ...data }: import("./board").UpdateBoardInfoBody) => Promise<any>;
+        retrieveBoardDetails: (id: string) => Promise<any>;
+        retrieveBoardInfoStatus: (id: string) => Promise<any>;
+        requestDetailsByEmail: ({ id, ...data }: RequestEmailBody) => Promise<any>;
+    };
+    userService: {
+        retrieveUserInfo: (userId: string) => Promise<any>;
+        getUserList: (data: GetUserListBody) => Promise<any>;
+        getUserListUsingSegmentId: (data: GetUserListSegmentBody) => Promise<any>;
+    };
+    brandService: {
+        retrieveBrand: (id: string) => Promise<any>;
+        getBrandList: (data: BrandListBody) => Promise<any>;
+        updateBrandInfo: ({ id, ...data }: UpdateBrandBody) => Promise<any>;
+        updateBrandSales: ({ id, ...data }: import("./individual").UpdateSalesChannels) => void;
+        getBrandListByIndividualId: (id: string) => Promise<any>;
+        removeBrandActivity: ({ id, ...data }: RemoveBrandActivity) => Promise<any>;
+    };
+    fileService: {
+        uploadFile: (data: UploadFileBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+        uploadFileInfo: (data: UploadFileBody, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<any>;
+        downloadFile: (id: string, name: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    documentService: {
+        updateDocumentInfo: (data: DocumentUpdateBody) => Promise<any>;
+        addFilesToExistingDocument: ({ id, ...data }: DocumentBody) => Promise<any>;
+        removeFilesFromDocument: ({ id, ...data }: DocumentBody) => Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    initService: {
+        getInitialData: (body: InitBody) => Promise<any>;
+    };
+    terminalService: {
+        unlinkTerminalDevice: ({ deviceId, ...payload }: UnlinkTerminalDeviceProps) => Promise<any>;
+        retrieveTerminalList: (merchants: string[], getTerminalDevice?: boolean) => Promise<any>;
+        retrievePOSDevices: (merchants: string[]) => Promise<any>;
+    };
+};
+export type { ValidateOperatorBody, CreateAuthBody, ExpressCreateAccountBody, VerifyAuthBody, CreateLeadBody, UpdateLeadBody, LeadVerifyBody, LeadOTPVerifyBody, CheckEmailBody, CheckBrandBody, LeadIdentityUpdateBody, EntityInfoBody, CreateAccountBody, EntityBankUpdateBody, CreatePasswordBody, BrandListBody, VerifyOperationAuthBody, ResetPasswordVerifyAuthBody, UpdateBoardBody, UpdateBrandBody, DataElementBody, UploadFileBody, UpdateEntityBody, DocumentUpdateBody, DocumentInfo, VerifyAuthExpressOTPBody, UpdateIndividualBody, UpdateEntityActivityBody, UpdateEntityCapitalBody, BankDocumentInfo, GetUserListBody, GetIndividualListBody, RequestEmailBody, DocumentBody, UpdateEntityAOAFileBody, InitBody, RemoveBrandActivity, RemoveEntityActivity, UpdateIndividualWithTypeBody, UpdateMultipleIndividualBody, ExpressLeadVerifyBody, ConfirmBody, ConfigBody, MerchantListBody, CreateEntityBody, CreateNafathAuthBody, GetUserListSegmentBody, CreateKYCAuthBody, GenerateAuthLinkNewTerminalProps, UnlinkTerminalDeviceProps, LinkTerminalDeviceProps };
+export { setAxiosGlobalHeaders, removeAxiosGlobalHeaders, axiosInstance, getAxiosHeaders };
+export default API;

package/build/api/index.js

@@ -0,0 +1,41 @@
+import axiosInstance, { setAxiosGlobalHeaders, removeAxiosGlobalHeaders, getAxiosHeaders } from './axios';
+import { locationService } from './location';
+import { operatorService } from './operator';
+import { countryService } from './country';
+import { authService } from './auth';
+import { leadService } from './lead';
+import availabilityServices from './availabilityServices';
+import { firebaseService } from './firebase';
+import { entityService } from './entity';
+import { accountService } from './account';
+import { dataService } from './data';
+import { individualService } from './individual';
+import { boardService } from './board';
+import { userService } from './user';
+import { brandService } from './brand';
+import { fileService } from './file';
+import { documentService } from './document';
+import { initService } from './init';
+import { terminalService } from './terminal';
+var API = {
+    locationService: locationService,
+    operatorService: operatorService,
+    countryService: countryService,
+    authService: authService,
+    leadService: leadService,
+    entityService: entityService,
+    availabilityServices: availabilityServices,
+    firebaseService: firebaseService,
+    accountService: accountService,
+    dataService: dataService,
+    individualService: individualService,
+    boardService: boardService,
+    userService: userService,
+    brandService: brandService,
+    fileService: fileService,
+    documentService: documentService,
+    initService: initService,
+    terminalService: terminalService
+};
+export { setAxiosGlobalHeaders, removeAxiosGlobalHeaders, axiosInstance, getAxiosHeaders };
+export default API;

package/build/api/individual.d.ts

@@ -0,0 +1,163 @@
+import { DocumentInfo } from './document';
+export declare type BrandListBody = {
+    individual_id: string;
+};
+export declare type UpdateBrandBody = {
+    id: string;
+    name?: {
+        en?: string;
+        ar?: string;
+    };
+    sectors?: Array<{
+        id: string;
+    }>;
+    website?: string;
+    social?: Array<string>;
+    logo?: string;
+    content?: {
+        tag_line?: {
+            en: string;
+            ar: string;
+            zh: string;
+        };
+        about?: {
+            en: string;
+            ar: string;
+            zh: string;
+        };
+    };
+    activities?: Array<{
+        id: string;
+    }>;
+    channel_services?: Array<{
+        id: string;
+        address: string;
+        sub?: Array<{
+            id: string;
+            address: string;
+        }>;
+    }>;
+    operations?: {
+        start_date?: string;
+        sales?: {
+            id: string;
+            period: string;
+            currency?: string;
+        };
+        customer_base?: {
+            id?: string;
+            period?: string;
+            locations?: Array<{
+                id: string;
+            }>;
+        };
+    };
+    segment?: {
+        location_type?: {
+            id: string;
+        };
+        profit_type?: {
+            id: string;
+        };
+        tech_type?: {
+            id: string;
+        };
+        type?: {
+            id: string;
+        };
+        team?: {
+            id: string;
+        };
+    };
+    term?: Array<string>;
+    step_name?: string;
+    encryption_contract?: Array<string>;
+    term_by?: string;
+};
+export declare type UpdateSalesChannels = {
+    id?: string;
+    channel_services: Array<{
+        id: string;
+        address: string;
+    }>;
+};
+export declare type UpdateIndividualBody = {
+    names?: {
+        en?: {
+            title?: string;
+            first?: string;
+            middle?: string;
+            third?: string;
+            last?: string;
+        };
+        ar?: {
+            title?: string;
+            first?: string;
+            middle?: string;
+            third?: string;
+            last?: string;
+        };
+    };
+    gender?: string;
+    contact?: {
+        email?: string;
+        phone?: {
+            country_code?: string;
+            number?: string;
+        };
+    };
+    date_of_birth?: string;
+    birth?: {
+        city?: string;
+        country?: string;
+    };
+    identification?: {
+        id?: string;
+        issued_country_code?: string;
+        expiry?: number;
+        type?: string;
+    };
+    shares?: {
+        count?: number;
+        value?: number;
+    };
+    nationality?: string;
+    employer_name?: string;
+    employer_country?: string | null;
+    source_income?: Array<{
+        id?: string;
+    }>;
+    monthly_income?: {
+        id?: string;
+    };
+    is_relative_PEP?: boolean | null;
+    is_influencer?: boolean | null;
+    documents?: Array<DocumentInfo | undefined>;
+    occupation?: {
+        chapter: {
+            id: string;
+        };
+    };
+    step_name?: string;
+    encryption_contract?: Array<string>;
+};
+export interface UpdateIndividualWithTypeBody extends UpdateIndividualBody {
+    id: string;
+    type: string;
+}
+export interface UpdateMultipleIndividualBody extends UpdateIndividualBody {
+    ids: Array<string>;
+}
+export declare type GetIndividualListBody = {
+    page: number;
+    limit: number;
+    business_id: string;
+};
+declare const individualService: {
+    retrieveIndividualInfo: (id: string) => Promise<any>;
+    retrieveIndividual: (id: string, type: string) => Promise<any>;
+    updateIndividual: ({ id, type, ...data }: UpdateIndividualWithTypeBody) => Promise<any>;
+    getIndividualList: (data: GetIndividualListBody) => Promise<any>;
+    updateMultipleIndividual: (data: UpdateMultipleIndividualBody) => Promise<any>;
+};
+export { individualService };

package/build/api/individual.js

@@ -0,0 +1,55 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ENDPOINT_PATHS } from '../constants';
+import { httpClient } from './axios';
+var retrieveIndividualInfo = function (id) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.USER, "/").concat(id, "/info")
+    });
+};
+var retrieveIndividual = function (id, type) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(type, "/").concat(id)
+    });
+};
+var updateIndividual = function (_a) {
+    var id = _a.id, type = _a.type, data = __rest(_a, ["id", "type"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(type, "/").concat(id),
+        data: data
+    });
+};
+var updateMultipleIndividual = function (data) {
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/multi"),
+        data: data
+    });
+};
+var getIndividualList = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/all"),
+        data: data
+    });
+};
+var individualService = {
+    retrieveIndividualInfo: retrieveIndividualInfo,
+    retrieveIndividual: retrieveIndividual,
+    updateIndividual: updateIndividual,
+    getIndividualList: getIndividualList,
+    updateMultipleIndividual: updateMultipleIndividual
+};
+export { individualService };

package/build/api/init.d.ts

@@ -0,0 +1,17 @@
+export declare type InitBody = {
+    type: string;
+    app_client_version: string;
+    requirer_browser: string;
+    os: string;
+    locale: string;
+    connect_pkey?: string;
+    data_required?: {
+        country_list?: boolean;
+        merchant?: boolean;
+    };
+    config_token?: string;
+};
+declare const initService: {
+    getInitialData: (body: InitBody) => Promise<any>;
+};
+export { initService };

package/build/api/init.js

@@ -0,0 +1,13 @@
+import { httpClient } from './axios';
+import { ENDPOINT_PATHS } from '../constants';
+var getInitialData = function (body) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.INIT,
+        data: body
+    });
+};
+var initService = {
+    getInitialData: getInitialData
+};
+export { initService };

package/build/api/lead.d.ts

@@ -0,0 +1,134 @@
+import { AxiosRequestConfig } from 'axios';
+import { LanguageMode } from '../@types';
+declare type Name = {
+    title?: string;
+    first?: string;
+    middle?: string;
+    last?: string;
+};
+declare type Contact = {
+    email?: string;
+    phone?: {
+        country_code?: string;
+        number?: string;
+    };
+};
+declare type BusinessName = {
+    en?: string;
+    ar?: string;
+};
+declare type BrandTitle = {
+    en?: string;
+    ar?: string;
+    zh?: string;
+};
+declare type MetaData = {
+    utm_source?: string;
+    utm_medium?: string;
+    utm_campaign?: string;
+    utm_term?: string;
+    utm_content?: string;
+};
+declare type BrandContent = {
+    tag_line?: BrandTitle;
+    about?: BrandTitle;
+};
+declare type BrandInfo = {
+    id?: string;
+    name?: BrandTitle;
+    sector?: Array<string>;
+    website?: string;
+    social?: Array<string>;
+    logo?: string;
+    content?: BrandContent;
+};
+export declare type UpdateLeadBody = {
+    step_name?: string;
+    id: string;
+    encryption_contract?: Array<string>;
+    entity?: {
+        id: string;
+    };
+    unified_number?: string;
+    name?: Name;
+    contact?: Contact;
+    send_invite?: boolean;
+    business_name?: BusinessName;
+    business_type?: string;
+    country_code?: string;
+    brand?: BrandInfo;
+    metadata?: MetaData;
+    note?: string;
+    source?: {
+        business_id?: string;
+        segment_id?: string;
+    };
+    license_number?: string;
+    license_type?: string;
+    is_acknowledged?: boolean;
+    terms_conditions_accepted?: boolean;
+    lang?: LanguageMode;
+    segment?: {
+        type: string;
+        team: string;
+    };
+    identification?: {
+        id?: string;
+        issued_country_code?: string;
+        type?: string;
+    };
+    date_of_birth?: string;
+};
+export declare type LeadVerifyBody = {
+    verify_token: string;
+    service_name: string;
+    notification?: {
+        sms: boolean;
+    };
+};
+export declare type CreateVerifyTokenBody = {
+    service_name: string;
+    board_id: string;
+    notification?: {
+        sms: boolean;
+    };
+};
+export declare type ExpressLeadVerifyBody = {
+    token: string;
+};
+export interface LeadOTPVerifyBody extends LeadVerifyBody {
+    data: string;
+    step_name: string;
+    encryption_contract: Array<string>;
+}
+export declare type CreateLeadBody = {
+    individual_id: string;
+    country_code: string;
+};
+export declare type LeadIdentityUpdateBody = {
+    id: string;
+    identification: {
+        id: string;
+        issued_country_code: string;
+        type: string;
+    };
+    date_of_birth?: string;
+    step_name?: string;
+    encryption_contract: Array<string>;
+};
+declare const leadService: {
+    createLead: (data: CreateLeadBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    updateLead: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
+    retrieveLead: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    getLeadById: (leadId: string) => Promise<any>;
+    verifyLeadToken: (data: LeadVerifyBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    verifyToken: (data: LeadVerifyBody) => Promise<any>;
+    verifyLeadOTP: (data: LeadOTPVerifyBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    verifyTokenOTP: (data: LeadOTPVerifyBody) => Promise<any>;
+    retrieveEntityList: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    retrieveLeadIdentity: (leadId: string) => Promise<any>;
+    updateLeadExpress: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
+    verifyExpressLeadToken: (data: ExpressLeadVerifyBody) => Promise<any>;
+    createVerifyTokenByBoardId: (data: CreateVerifyTokenBody) => Promise<any>;
+};
+export { leadService };