@tap-payments/auth-jsconnect 2.0.46-test → 2.0.46

package/build/@types/user.d.ts

@@ -0,0 +1,141 @@
+export interface User {
+    id: string;
+    type: string;
+    status: string;
+    created: number;
+    names: Names;
+    contact: Contact;
+    nationality: string;
+    gender: string;
+    birth: Birth;
+    identification: Identification;
+    role: Role[];
+    is_authorized: boolean;
+    verification: Verification;
+    source_income: Role[];
+    occupation: Role;
+    entities: Entity[];
+    documents: string[];
+    monthly_income: Role;
+    employer_country: string;
+    is_relative_PEP: boolean;
+    is_influencer: boolean;
+    is_verified: boolean;
+    individual_id: string;
+    data_status: DataStatus;
+    data_verification: DataVerification;
+    isRequestedEmail?: boolean;
+}
+interface DataVerification {
+    status: string;
+    name: string;
+    contact: Contact;
+    nationality: string;
+    birth: BirthDataVerify;
+    identification: IdentificationDataVerify;
+    role: string;
+    relation: string;
+    occupation: string;
+    address: string;
+    is_authorized: string;
+    source_of_income: string;
+    monthly_income: string;
+    is_relative_PEP: string;
+    is_influencer: string;
+}
+interface BirthDataVerify {
+    date: string;
+    city: string;
+    country: string;
+}
+interface DataStatus {
+    status: string;
+    name: string;
+    contact: Contact;
+    nationality: string;
+    identification: IdentificationDataVerify;
+    role: string;
+    relation: string;
+    occupation: string;
+    address: string;
+    is_authorized: string;
+    source_of_income: string;
+    monthly_income: string;
+    is_relative_PEP: string;
+    is_influencer: string;
+}
+interface IdentificationDataVerify {
+    id: string;
+    type: string;
+    expiry: string;
+    issuer_country: string;
+}
+interface Entity {
+    id: string;
+    operator_id: string;
+}
+interface Verification {
+    national_id: NationalId;
+    identification: NationalId;
+    phone: NationalId;
+    date_of_birth: NationalId;
+    name: NationalId;
+    login: NationalId;
+    email: Email;
+}
+interface Email {
+    type: string;
+    is_verified: boolean;
+    verified_at: number;
+}
+interface NationalId {
+    type: string;
+    is_verified: boolean;
+    verified_at: number;
+    verified_by: string;
+}
+interface Role {
+    id: string;
+    name: Name;
+}
+interface Name {
+    ar: string;
+    en: string;
+}
+interface Identification {
+    id: string;
+    issued_country_code: string;
+    type: string;
+    expiry: number;
+}
+interface Birth {
+    date: number;
+    city: string;
+    country: string;
+}
+interface Contact {
+    email: string;
+    phone: Phone;
+}
+interface Phone {
+    country_code: string;
+    number: string;
+}
+interface Names {
+    ar: Ar;
+    en: En;
+}
+interface En {
+    title: string;
+    first: string;
+    middle: string;
+    last: string;
+    third: string;
+}
+interface Ar {
+    first: string;
+    middle: string;
+    last: string;
+    third: string;
+}
+export {};

package/build/@types/user.js

@@ -0,0 +1 @@
+export {};

package/build/api/account.d.ts

@@ -1,4 +1,4 @@
-export declare type CreateAccountBody = {
+export type CreateAccountBody = {
     lead_id: string;
     notify: {
         email: boolean;
@@ -8,7 +8,12 @@ export declare type CreateAccountBody = {
     is_acknowledged: boolean;
     step_name: string;
 };
+export type ExpressCreateAccountBody = {
+    post_url: string;
+    lead_id: string;
+};
 declare const accountService: {
     createAccount: (data: CreateAccountBody) => Promise<any>;
+    expressCreateAccount: (data: ExpressCreateAccountBody) => Promise<any>;
 };
 export { accountService };

package/build/api/account.js

@@ -7,7 +7,15 @@ var createAccount = function (data) {
         data: data
     });
 };
+var expressCreateAccount = function (data) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.EXPRESS_CREATE_ACCOUNT,
+        data: data
+    });
+};
 var accountService = {
-    createAccount: createAccount
+    createAccount: createAccount,
+    expressCreateAccount: expressCreateAccount
 };
 export { accountService };

package/build/api/auth.d.ts

@@ -1,64 +1,93 @@
 import { AxiosRequestConfig } from 'axios';
 import { LanguageMode } from '../@types';
-export declare type MobileCredential = {
+export type MobileCredential = {
     code: string;
     phone: string;
 };
-export declare type EmailCredential = {
+export type EmailCredential = {
     email: string;
 };
-export declare type IDCredential = {
-    country_code: string;
+export type IDCredential = {
+    country_code?: string;
+    identification_id: string;
+    identification_id_type?: string;
+    date_of_birth?: string;
+};
+export type CivilID = {
     identification_id: string;
-    identification_id_type: string;
-    date_of_birth: string;
+    country_code: string;
 };
-export declare type CreateAuthBody = {
-    user_credentail: MobileCredential | EmailCredential | IDCredential;
+export type CreateAuthBody = {
+    country: string;
+    scope: string;
+    user_credentail: MobileCredential | EmailCredential | IDCredential | CivilID;
     auth_type?: number;
     email_url?: string;
     sign_in?: boolean;
+    is_lead?: boolean;
     step_name?: string;
     encryption_contract: Array<string>;
     lang?: LanguageMode;
+    lead_id?: string;
 };
-export declare type VerifyAuthBody = {
+export type VerifyAuthBody = {
     auth_token: string;
     auth_type: number;
     data: string;
     device_token: string;
     step_name: string;
     service_name: string;
-    new_user: boolean;
+    new_user?: boolean;
     sign_in: boolean;
     encryption_contract: Array<string>;
     remember_me?: boolean;
-    scopes?: Array<string>;
 };
-export declare type VerifyOperationAuthBody = {
+export type VerifyOperationAuthBody = {
     auth_token: string;
     auth_type: number;
 };
-export declare type ResetPasswordCredential = {
+export type ResetPasswordCredential = {
     otp: string;
     new_password: string;
 };
-export declare type ResetPasswordVerifyAuthBody = {
+export type ResetPasswordVerifyAuthBody = {
     auth_token: string;
     auth_type: number;
     step_name: string;
     user_credentail: ResetPasswordCredential;
     encryption_contract: Array<string>;
 };
-export declare type CreatePasswordBody = {
+export type CreatePasswordBody = {
     password: string;
     signup_token?: string;
     step_name: string;
     encryption_contract: Array<string>;
 };
+export type VerifyAuthExpressOTPBody = {
+    auth_token?: string;
+    verify_token?: string;
+    lead_id?: string;
+    data: string;
+    auth_type?: number;
+    service_name: string;
+    sign_in: boolean;
+    step_name?: string;
+    device_token?: string;
+    post_url?: string;
+    scopes?: Array<string>;
+    terms?: Array<string>;
+    encryption_contract: Array<string>;
+};
 declare const authService: {
-    createAuth: (data: CreateAuthBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    createAuth: (data: CreateAuthBody, config?: AxiosRequestConfig) => Promise<any>;
     verifyAuth: (data: VerifyAuthBody | VerifyOperationAuthBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
     createPassword: (data: CreatePasswordBody) => Promise<any>;
+    verifyExpressAuth: (data: VerifyAuthExpressOTPBody) => Promise<any>;
+    getVerifyAuth: (token: string, config?: AxiosRequestConfig) => Promise<any>;
+    getTokenVerify: (token: string, config?: AxiosRequestConfig) => Promise<any>;
+    createAuthKitNID: (data: CreateAuthBody) => Promise<any>;
+    createExpressAuth: (data: CreateAuthBody, config?: AxiosRequestConfig) => Promise<any>;
+    verifyExpressLeadIdentity: (data: VerifyAuthExpressOTPBody) => Promise<any>;
+    createExpressLeadIdentityAuth: (data: CreateAuthBody) => Promise<any>;
 };
 export { authService };

package/build/api/auth.js

@@ -1,7 +1,21 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import instance, { httpClient } from './axios';
 import { ENDPOINT_PATHS } from '../constants';
 var createAuth = function (data, config) {
-    return instance.post("".concat(ENDPOINT_PATHS.AUTH), data, config);
+    return httpClient(__assign({ method: 'post', url: "".concat(ENDPOINT_PATHS.AUTH), data: data }, config));
+};
+var createExpressAuth = function (data, config) {
+    return httpClient(__assign({ method: 'post', url: "".concat(ENDPOINT_PATHS.CREATE_EXPRESS_AUTH_PATH), data: data }, config));
 };
 var verifyAuth = function (data, config) {
     return instance.put("".concat(ENDPOINT_PATHS.AUTH), data, config);
@@ -13,9 +27,50 @@ var createPassword = function (data) {
         data: data
     });
 };
+var getVerifyAuth = function (token, config) {
+    return httpClient(__assign({ method: 'get', url: "".concat(ENDPOINT_PATHS.AUTH, "/").concat(token) }, config));
+};
+var getTokenVerify = function (token, config) {
+    return httpClient(__assign({ method: 'get', url: "".concat(ENDPOINT_PATHS.TOKEN_VERIFY, "/").concat(token) }, config));
+};
+var verifyExpressAuth = function (data) {
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.Verify_Express_Auth_OTP_PATH),
+        data: data
+    });
+};
+var verifyExpressLeadIdentity = function (data) {
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.EXPRESS_LEAD_IDENTITY_AUTH_PATH),
+        data: data
+    });
+};
+var createExpressLeadIdentityAuth = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.EXPRESS_LEAD_IDENTITY_AUTH_PATH),
+        data: data
+    });
+};
+var createAuthKitNID = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.CREATE_AUTH_NID),
+        data: data
+    });
+};
 var authService = {
     createAuth: createAuth,
     verifyAuth: verifyAuth,
-    createPassword: createPassword
+    createPassword: createPassword,
+    verifyExpressAuth: verifyExpressAuth,
+    getVerifyAuth: getVerifyAuth,
+    getTokenVerify: getTokenVerify,
+    createAuthKitNID: createAuthKitNID,
+    createExpressAuth: createExpressAuth,
+    verifyExpressLeadIdentity: verifyExpressLeadIdentity,
+    createExpressLeadIdentityAuth: createExpressLeadIdentityAuth
 };
 export { authService };

package/build/api/availabilityServices.d.ts

@@ -1,14 +1,14 @@
 import { AxiosRequestConfig } from 'axios';
-export declare type CheckEmailBody = {
+export type CheckEmailBody = {
     email: string | null;
     encryption_contract: Array<string>;
 };
-export declare type CheckBrandBody = {
+export type CheckBrandBody = {
     profile_name: string;
     country_code: string;
     encryption_contract: Array<string>;
 };
-export declare type CheckIBanBody = {
+export type CheckIBanBody = {
     iban_number: string;
     encryption_contract?: Array<string>;
 };

package/build/api/axios.js

@@ -13,7 +13,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) 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]) {
@@ -91,8 +91,8 @@ export var httpClient = function (config) { return __awaiter(void 0, void 0, voi
             case 1:
                 data = (_c.sent()).data;
                 _a = (data.errors || [{}])[0], description = _a.description, error = _a.error;
-                if (description || error) {
-                    throw new Error(description, error);
+                if (description || error || (data === null || data === void 0 ? void 0 : data.status) === 'fail' || data.mw_error) {
+                    throw new Error(description || error || (data === null || data === void 0 ? void 0 : data.message) || data.mw_error || 'Internal server error');
                 }
                 return [2, data];
             case 2:

package/build/api/board.d.ts

@@ -1,26 +1,43 @@
-export declare type UpdateBoardBody = {
+export type UpdateBoardBody = {
     id?: string;
     infoId?: string;
     step_name: string;
     lang: string;
     encryption_contract?: string;
 };
-export declare type RetrieveBoardInfoBody = {
+export type RetrieveBoardInfoBody = {
     id: string;
     infoId: string;
 };
-export declare type UpdateBoardInfoBody = {
+export type UpdateBoardInfoBody = {
     id: string;
     infoId: string;
     step_name: string;
     lang: string;
     encryption_contract?: string;
 };
+export interface RequestEmailBody {
+    id: string;
+    merchant_id: string;
+    info: Array<{
+        name: string;
+    }>;
+    notification: Notification;
+}
+interface Notification {
+    recipient: {
+        id: string;
+        type: string;
+    };
+    channel: string[];
+}
 declare const boardService: {
     retrieveBoard: (id: string) => Promise<any>;
     updateBoard: ({ id, ...data }: UpdateBoardBody) => Promise<any>;
     retrieveBoardInfo: ({ id, infoId }: RetrieveBoardInfoBody) => Promise<any>;
     updateBoardInfo: ({ id, infoId, ...data }: UpdateBoardInfoBody) => Promise<any>;
     retrieveBoardDetails: (id: string) => Promise<any>;
+    retrieveBoardInfoStatus: (id: string) => Promise<any>;
+    requestDetailsByEmail: ({ id, ...data }: RequestEmailBody) => Promise<any>;
 };
 export { boardService };

package/build/api/board.js

@@ -18,6 +18,12 @@ var retrieveBoardInfo = function (_a) {
         url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id, "/info/collect/").concat(infoId)
     });
 };
+var retrieveBoardInfoStatus = function (id) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id, "/info/status")
+    });
+};
 var retrieveBoard = function (id) {
     return httpClient({
         method: 'get',
@@ -46,11 +52,21 @@ var updateBoardInfo = function (_a) {
         data: data
     });
 };
+var requestDetailsByEmail = function (_a) {
+    var id = _a.id, data = __rest(_a, ["id"]);
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id, "/info/collect"),
+        data: data
+    });
+};
 var boardService = {
     retrieveBoard: retrieveBoard,
     updateBoard: updateBoard,
     retrieveBoardInfo: retrieveBoardInfo,
     updateBoardInfo: updateBoardInfo,
-    retrieveBoardDetails: retrieveBoardDetails
+    retrieveBoardDetails: retrieveBoardDetails,
+    retrieveBoardInfoStatus: retrieveBoardInfoStatus,
+    requestDetailsByEmail: requestDetailsByEmail
 };
 export { boardService };

package/build/api/brand.d.ts

@@ -1,7 +1,9 @@
-import { BrandListBody, UpdateBrandBody } from '../api/individual';
+import { BrandListBody, UpdateBrandBody, UpdateSalesChannels } from '../api/individual';
 declare const brandService: {
     retrieveBrand: (id: string) => Promise<any>;
     getBrandList: (data: BrandListBody) => Promise<any>;
     updateBrandInfo: ({ id, ...data }: UpdateBrandBody) => Promise<any>;
+    updateBrandSales: ({ id, ...data }: UpdateSalesChannels) => void;
+    getBrandListByIndividualId: (id: string) => Promise<any>;
 };
 export { brandService };

package/build/api/brand.js

@@ -24,6 +24,13 @@ var getBrandList = function (data) {
         data: data
     });
 };
+var getBrandListByIndividualId = function (id) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.BRAND_LIST),
+        data: { individual_id: id }
+    });
+};
 var updateBrandInfo = function (_a) {
     var id = _a.id, data = __rest(_a, ["id"]);
     return httpClient({
@@ -32,9 +39,19 @@ var updateBrandInfo = function (_a) {
         data: data
     });
 };
+var updateBrandSales = function (_a) {
+    var id = _a.id, data = __rest(_a, ["id"]);
+    httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.BRAND_SALES_CHANNELS, "/").concat(id),
+        data: data
+    });
+};
 var brandService = {
     retrieveBrand: retrieveBrand,
     getBrandList: getBrandList,
-    updateBrandInfo: updateBrandInfo
+    updateBrandInfo: updateBrandInfo,
+    updateBrandSales: updateBrandSales,
+    getBrandListByIndividualId: getBrandListByIndividualId
 };
 export { brandService };

package/build/api/country.d.ts

@@ -1,4 +1,10 @@
+export type GetCitiesBody = {
+    country: string[];
+};
 declare const countryService: {
-    getCountries: () => Promise<any>;
+    getCountries: (disableCountries?: boolean) => Promise<any> | {
+        list: never[];
+    };
+    getCities: (data: GetCitiesBody) => Promise<any>;
 };
 export { countryService };

package/build/api/country.js

@@ -1,12 +1,22 @@
 import { httpClient } from './axios';
 import { ENDPOINT_PATHS } from '../constants';
-var getCountries = function () {
+var getCountries = function (disableCountries) {
+    if (disableCountries)
+        return { list: [] };
     return httpClient({
         method: 'post',
         url: ENDPOINT_PATHS.COUNTRIES
     });
 };
+var getCities = function (data) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.CITIES,
+        data: data
+    });
+};
 var countryService = {
-    getCountries: getCountries
+    getCountries: getCountries,
+    getCities: getCities
 };
 export { countryService };

package/build/api/data.d.ts

@@ -1,10 +1,49 @@
+import { AxiosRequestConfig } from 'axios';
+type GetOccupationBody = {
+    page: number;
+};
+type GetSegmentsBody = {
+    page: number;
+};
+type GetTeamSizeBody = {
+    page: number;
+};
+type GetMonthlyIncomeBody = {
+    page: number;
+    country_code: Array<string>;
+};
+export type DataElementBody = {
+    id: string;
+    name: {
+        en: string;
+        ar: string;
+    };
+};
+type GetCustomerBasesBody = {
+    page: number;
+};
+type GetExpectedSalesBody = {
+    page: number;
+};
+type GetExpectedCustomerSalesBody = {
+    page: number;
+};
+type GetSourceOfIncomeBody = {
+    page: number;
+};
+type GetChannelsOfServicesBody = {
+    page: number;
+};
 declare const dataService: {
-    getChannelsOfServices: () => Promise<import("axios").AxiosResponse<any, any>>;
-    getCustomerBases: () => Promise<import("axios").AxiosResponse<any, any>>;
-    getExpectedSales: () => Promise<import("axios").AxiosResponse<any, any>>;
-    getExpectedCustomerSales: () => Promise<import("axios").AxiosResponse<any, any>>;
-    getSourceOfIncome: () => Promise<import("axios").AxiosResponse<any, any>>;
-    getMonthlyIncome: (countryCode: string) => Promise<import("axios").AxiosResponse<any, any>>;
-    getOccupation: () => Promise<any>;
+    getChannelsOfServices: (data: GetChannelsOfServicesBody) => Promise<any>;
+    getCustomerBases: (data: GetCustomerBasesBody) => Promise<any>;
+    getExpectedSales: (data: GetExpectedSalesBody) => Promise<any>;
+    getExpectedCustomerSales: (data: GetExpectedCustomerSalesBody) => Promise<any>;
+    getSourceOfIncome: (data: GetSourceOfIncomeBody) => Promise<any>;
+    getMonthlyIncome: (data: GetMonthlyIncomeBody) => Promise<any>;
+    getOccupation: (data: GetOccupationBody) => Promise<any>;
+    getSegments: (data: GetSegmentsBody) => Promise<any>;
+    getTeamSize: (data: GetTeamSizeBody) => Promise<any>;
+    getActivities: (config?: AxiosRequestConfig) => Promise<any>;
 };
 export { dataService };