@provis/provis-common-be-module 1.4.38 → 1.4.39

package/dist/constants/product.d.ts

@@ -0,0 +1,64 @@
+declare const product: {
+    LIST: {};
+    PRODUCT_POLISMALL_CARGO_MERATUS: string;
+    PRODUCT_POLISMALL_CARGO: string;
+    PRODUCT_CODE_PROPERTY_ALL_RISK: string;
+    PRODUCT_CODE_EARTHQUAKE: string;
+    PRODUCT_CODE_VEHICLE: string;
+    PRODUCT_CODE_PUBLIC_LIABILITY: string;
+    PRODUCT_CODE_MACHINERYR_BREAKDOWN: string;
+    PRODUCT_CODE_TERRORISM_SABOTAGE: string;
+    PRODUCT_CODE_COMPREHENSIVE_LIABILITY: string;
+    PRODUCT_CODE_CONTAINER: string;
+    PRODUCT_CODE_GROUP_HEALTH: string;
+    PRODUCT_CODE_TRAVEL: string;
+    PRODUCT_CODE_HOSPITAL_CASH_PLAN: string;
+    PRODUCT_CODE_TERM_LIFE: string;
+    PRODUCT_CODE_PERSONAL_ACCIDENT: string;
+    PRODUCT_CODE_TAILOR_MADE: string;
+    PRODUCT_CODE_CRITICAL_ILLNESS: string;
+    PRODUCT_CODE_FREIGHT_FORWARDER_LIABILITY: string;
+    PRODUCT_CODE_MARINE_HULL: string;
+    PRODUCT_CODE_CREDIT_LIFE: string;
+    PRODUCT_CODE_TRADITIONAL_WHOLE_LIFE: string;
+    PRODUCT_CODE_CARPAKR_LIABILITY: string;
+    PRODUCT_CODE_DIRECTOR_OFFICER_LIABILITY: string;
+    PRODUCT_CODE_PROFESIONAL_INDEMNITY: string;
+    PRODUCT_CODE_GENERAL_LIABILITY: string;
+    PRODUCT_CODE_WEDDING: string;
+    PRODUCT_CODE_PENSIUN_FUND: string;
+    PRODUCT_CODE_PENSION_FUND: string;
+    PRODUCT_CODE_ENVIRONMENTAL_LIABILITY: string;
+    PRODUCT_CODE_PROTECTION_INDEMNITY: string;
+    PRODUCT_CODE_STUDENT_PROTECTION: string;
+    PRODUCT_CODE_GADGET: string;
+    PRODUCT_CODE_ELECTRONIC_EQUIPMENT: string;
+    PRODUCT_CODE_CPM: string;
+    PRODUCT_CODE_CONSTRUCTION_ALLRISK: string;
+    PRODUCT_CODE_MERIMEN_CARGO: string;
+    PRODUCT_CODE_HCI_MOTOR: string;
+    PRODUCT_CODE_HCP5_DISEASE: string;
+    PRODUCT_CODE_EXIM: string;
+    PRODUCT_CODE_MOVEABLE_ALL_RISK: string;
+    PRODUCT_CODE_SURETY_BOND: string;
+    PRODUCT_CODE_ERECTION_ALL_RISK: string;
+    PRODUCT_CODE_OTTO_CI: string;
+    PRODUCT_CODE_OTTO_FLEXAS: string;
+    PRODUCT_CODE_OTTO_CRACK_SCREEN: string;
+    PRODUCT_CODE_OTTO_AUM_GP: string;
+    PRODUCT_CODE_OTTO_AUM_PLN: string;
+    PRODUCT_CODE_OTTO_AUM_PDAM: string;
+    PRODUCT_CODE_OTTO_AUM_SB: string;
+    PRODUCT_CODE_OTTO_AUM_FB: string;
+    PRODUCT_CODE_OTTO_AUM_FBK: string;
+    PRODUCT_CODE_BDKI_MOTOR: string;
+    PRODUCT_CODE_BDKI_RUMAH: string;
+    PRODUCT_CODE_BNI_MOBIL: string;
+    PRODUCT_CODE_BNI_MOTOR: string;
+    PRODUCT_CODE_BNI_RUMAH: string;
+    PRODUCT_CODE_CARGO_BUNDLE: string;
+    PRODUCT_CODE_RETAIL_LOKET_PA: string;
+    PRODUCT_CODE_RETAIL_KALOG_CARGO: string;
+    PRODUCT_CODE_RETAIL_POS_CARGO: string;
+};
+export default product;

package/dist/constants/product.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const product = {
+    LIST: {},
+    PRODUCT_POLISMALL_CARGO_MERATUS: 'polismall-cargo-meratus',
+    PRODUCT_POLISMALL_CARGO: 'polismall-cargo',
+    PRODUCT_CODE_PROPERTY_ALL_RISK: 'polismall-property-allrisk',
+    PRODUCT_CODE_EARTHQUAKE: 'polismall-earthquake',
+    PRODUCT_CODE_VEHICLE: 'polismall-vehicle',
+    PRODUCT_CODE_PUBLIC_LIABILITY: 'polismall-public-liability',
+    PRODUCT_CODE_MACHINERYR_BREAKDOWN: 'polismall-machinery-breakdown',
+    PRODUCT_CODE_TERRORISM_SABOTAGE: 'polismall-terrorism-sabotage',
+    PRODUCT_CODE_COMPREHENSIVE_LIABILITY: 'polismall-comprehensive-liability',
+    PRODUCT_CODE_CONTAINER: 'polismall-container',
+    PRODUCT_CODE_GROUP_HEALTH: 'polismall-group-health',
+    PRODUCT_CODE_TRAVEL: 'polismall-travel',
+    PRODUCT_CODE_HOSPITAL_CASH_PLAN: 'polismall-hospital-cash-plan',
+    PRODUCT_CODE_TERM_LIFE: 'polismall-term-life',
+    PRODUCT_CODE_PERSONAL_ACCIDENT: 'polismall-personal-accident',
+    PRODUCT_CODE_TAILOR_MADE: 'polismall-tailor-made',
+    PRODUCT_CODE_CRITICAL_ILLNESS: 'polismall-critical-illness',
+    PRODUCT_CODE_FREIGHT_FORWARDER_LIABILITY: 'polismall-freight-forwarder-liability',
+    PRODUCT_CODE_MARINE_HULL: 'polismall-marine-hull',
+    PRODUCT_CODE_CREDIT_LIFE: 'polismall-credit-life',
+    PRODUCT_CODE_TRADITIONAL_WHOLE_LIFE: 'polismall-traditional-whole-life',
+    PRODUCT_CODE_CARPAKR_LIABILITY: 'polismall-carpark-liability',
+    PRODUCT_CODE_DIRECTOR_OFFICER_LIABILITY: 'polismall-director-officer-liability',
+    PRODUCT_CODE_PROFESIONAL_INDEMNITY: 'polismall-professional-indemnity',
+    PRODUCT_CODE_GENERAL_LIABILITY: 'polismall-general-liability',
+    PRODUCT_CODE_WEDDING: 'polismall-wedding',
+    PRODUCT_CODE_PENSIUN_FUND: 'polismall-pensiun-fund',
+    PRODUCT_CODE_PENSION_FUND: 'polismall-pension-fund',
+    PRODUCT_CODE_ENVIRONMENTAL_LIABILITY: 'polismall-environmental-liability',
+    PRODUCT_CODE_PROTECTION_INDEMNITY: 'polismall-protection-indemnity',
+    PRODUCT_CODE_STUDENT_PROTECTION: 'polismall-student-protection',
+    PRODUCT_CODE_GADGET: 'polismall-gadget',
+    PRODUCT_CODE_ELECTRONIC_EQUIPMENT: 'polismall-electronic-equipment',
+    PRODUCT_CODE_CPM: 'polismall-cpm',
+    PRODUCT_CODE_CONSTRUCTION_ALLRISK: 'polismall-construction-allrisk',
+    PRODUCT_CODE_MERIMEN_CARGO: 'polismall-merimen-cargo',
+    PRODUCT_CODE_HCI_MOTOR: 'polismall-hci-motor',
+    PRODUCT_CODE_HCP5_DISEASE: 'polismall-hcp5-disease',
+    PRODUCT_CODE_EXIM: 'polismall-exim',
+    PRODUCT_CODE_MOVEABLE_ALL_RISK: 'polismall-moveable-all-risk',
+    PRODUCT_CODE_SURETY_BOND: 'polismall-surety-bond',
+    PRODUCT_CODE_ERECTION_ALL_RISK: 'polismall-erection-all-risk',
+    // OTTO
+    PRODUCT_CODE_OTTO_CI: 'polismall-otto-critical-illness',
+    PRODUCT_CODE_OTTO_FLEXAS: 'polismall-otto-flexas',
+    PRODUCT_CODE_OTTO_CRACK_SCREEN: 'polismall-otto-crack',
+    PRODUCT_CODE_OTTO_AUM_GP: 'polismall-otto-aum-gp',
+    PRODUCT_CODE_OTTO_AUM_PLN: 'polismall-otto-aum-pln',
+    PRODUCT_CODE_OTTO_AUM_PDAM: 'polismall-otto-aum-pdam',
+    PRODUCT_CODE_OTTO_AUM_SB: 'polismall-otto-aum-sb',
+    PRODUCT_CODE_OTTO_AUM_FB: 'polismall-otto-aum-fb',
+    PRODUCT_CODE_OTTO_AUM_FBK: 'polismall-otto-aum-fbk',
+    // BDKI
+    PRODUCT_CODE_BDKI_MOTOR: 'polismall-bdki-motor',
+    PRODUCT_CODE_BDKI_RUMAH: 'polismall-bdki-rumah',
+    // BNI
+    PRODUCT_CODE_BNI_MOBIL: 'polismall-bni-mobil',
+    PRODUCT_CODE_BNI_MOTOR: 'polismall-bni-motor',
+    PRODUCT_CODE_BNI_RUMAH: 'polismall-bni-rumah',
+    // BUNDLE
+    PRODUCT_CODE_CARGO_BUNDLE: 'polismall-cargo-bundle',
+    // [PM] POLISMALL RETAIL
+    PRODUCT_CODE_RETAIL_LOKET_PA: 'polismall-loket-pa',
+    PRODUCT_CODE_RETAIL_KALOG_CARGO: 'polismall-kalog-cargo',
+    PRODUCT_CODE_RETAIL_POS_CARGO: 'polismall-pos-cargo',
+};
+product.LIST = {
+    [product.PRODUCT_CODE_BNI_MOBIL]: {
+        value: product.PRODUCT_CODE_BNI_MOBIL,
+        name: "BNI Oto Warranty Plus",
+    },
+    [product.PRODUCT_CODE_BNI_MOTOR]: {
+        value: product.PRODUCT_CODE_BNI_MOTOR,
+        name: "BNI Motor Guard",
+    },
+    [product.PRODUCT_CODE_BNI_RUMAH]: {
+        value: product.PRODUCT_CODE_BNI_RUMAH,
+        name: "BNI Home Guard",
+    },
+    [product.PRODUCT_CODE_OTTO_CI]: {
+        value: product.PRODUCT_CODE_OTTO_CI,
+        name: "Otto Critical Illness",
+    },
+    [product.PRODUCT_CODE_OTTO_FLEXAS]: {
+        value: product.PRODUCT_CODE_OTTO_FLEXAS,
+        name: "Otto Biller Protection",
+    },
+    [product.PRODUCT_CODE_OTTO_CRACK_SCREEN]: {
+        value: product.PRODUCT_CODE_OTTO_CRACK_SCREEN,
+        name: "Smartphone Protection",
+    },
+    [product.PRODUCT_POLISMALL_CARGO]: {
+        value: product.PRODUCT_POLISMALL_CARGO,
+        name: "Polismall Marine Cargo",
+    },
+    [product.PRODUCT_POLISMALL_CARGO_MERATUS]: {
+        value: product.PRODUCT_POLISMALL_CARGO_MERATUS,
+        name: "Microsite Marine Cargo",
+    },
+    [product.PRODUCT_CODE_PROPERTY_ALL_RISK]: {
+        value: product.PRODUCT_CODE_PROPERTY_ALL_RISK,
+        name: "Property All Risk",
+    },
+    [product.PRODUCT_CODE_EARTHQUAKE]: {
+        value: product.PRODUCT_CODE_EARTHQUAKE,
+        name: "Earthquake",
+    },
+    [product.PRODUCT_CODE_VEHICLE]: {
+        value: product.PRODUCT_CODE_VEHICLE,
+        name: "Motor Vehicle",
+    },
+    [product.PRODUCT_CODE_PUBLIC_LIABILITY]: {
+        value: product.PRODUCT_CODE_PUBLIC_LIABILITY,
+        name: "Public Liability",
+    },
+    [product.PRODUCT_CODE_MACHINERYR_BREAKDOWN]: {
+        value: product.PRODUCT_CODE_MACHINERYR_BREAKDOWN,
+        name: "Machinery Breakdown",
+    },
+    [product.PRODUCT_CODE_TERRORISM_SABOTAGE]: {
+        value: product.PRODUCT_CODE_TERRORISM_SABOTAGE,
+        name: "Terrorism and Sabotage",
+    },
+    [product.PRODUCT_CODE_COMPREHENSIVE_LIABILITY]: {
+        value: product.PRODUCT_CODE_COMPREHENSIVE_LIABILITY,
+        name: "Comprehensive General Liability",
+    },
+    [product.PRODUCT_CODE_CONTAINER]: {
+        value: product.PRODUCT_CODE_CONTAINER,
+        name: "Container Insurance",
+    },
+    [product.PRODUCT_CODE_GROUP_HEALTH]: {
+        value: product.PRODUCT_CODE_GROUP_HEALTH,
+        name: "Group Health Insurance",
+    },
+    [product.PRODUCT_CODE_TRAVEL]: {
+        value: product.PRODUCT_CODE_TRAVEL,
+        name: "Travel",
+    },
+    [product.PRODUCT_CODE_HOSPITAL_CASH_PLAN]: {
+        value: product.PRODUCT_CODE_HOSPITAL_CASH_PLAN,
+        name: "Hospital Cash Plan",
+    },
+    [product.PRODUCT_CODE_TERM_LIFE]: {
+        value: product.PRODUCT_CODE_TERM_LIFE,
+        name: "Term Life",
+    },
+    [product.PRODUCT_CODE_PERSONAL_ACCIDENT]: {
+        value: product.PRODUCT_CODE_PERSONAL_ACCIDENT,
+        name: "Personal Accident",
+    },
+    [product.PRODUCT_CODE_TAILOR_MADE]: {
+        value: product.PRODUCT_CODE_TAILOR_MADE,
+        name: "Tailor Made",
+    },
+    [product.PRODUCT_CODE_CRITICAL_ILLNESS]: {
+        value: product.PRODUCT_CODE_CRITICAL_ILLNESS,
+        name: "Critical Illness",
+    },
+    [product.PRODUCT_CODE_FREIGHT_FORWARDER_LIABILITY]: {
+        value: product.PRODUCT_CODE_FREIGHT_FORWARDER_LIABILITY,
+        name: "Freight Forwarder Liability",
+    },
+    [product.PRODUCT_CODE_MARINE_HULL]: {
+        value: product.PRODUCT_CODE_MARINE_HULL,
+        name: "Marine Hull",
+    },
+    [product.PRODUCT_CODE_CREDIT_LIFE]: {
+        value: product.PRODUCT_CODE_CREDIT_LIFE,
+        name: "Credit Life",
+    },
+    [product.PRODUCT_CODE_TRADITIONAL_WHOLE_LIFE]: {
+        value: product.PRODUCT_CODE_TRADITIONAL_WHOLE_LIFE,
+        name: "Traditional Whole Life",
+    },
+    [product.PRODUCT_CODE_CARPAKR_LIABILITY]: {
+        value: product.PRODUCT_CODE_CARPAKR_LIABILITY,
+        name: "Carpark Liability",
+    },
+    [product.PRODUCT_CODE_DIRECTOR_OFFICER_LIABILITY]: {
+        value: product.PRODUCT_CODE_DIRECTOR_OFFICER_LIABILITY,
+        name: "Director Officer Liability",
+    },
+    [product.PRODUCT_CODE_PROFESIONAL_INDEMNITY]: {
+        value: product.PRODUCT_CODE_PROFESIONAL_INDEMNITY,
+        name: "Professional Indemnity",
+    },
+    [product.PRODUCT_CODE_GENERAL_LIABILITY]: {
+        value: product.PRODUCT_CODE_GENERAL_LIABILITY,
+        name: "General Liability",
+    },
+    [product.PRODUCT_CODE_WEDDING]: {
+        value: product.PRODUCT_CODE_WEDDING,
+        name: "General Wedding",
+    },
+    [product.PRODUCT_CODE_PENSIUN_FUND]: {
+        value: product.PRODUCT_CODE_PENSIUN_FUND,
+        name: "Pensiun Fund",
+    },
+    [product.PRODUCT_CODE_ENVIRONMENTAL_LIABILITY]: {
+        value: product.PRODUCT_CODE_ENVIRONMENTAL_LIABILITY,
+        name: "Environmental Liability",
+    },
+    [product.PRODUCT_CODE_PROTECTION_INDEMNITY]: {
+        value: product.PRODUCT_CODE_PROTECTION_INDEMNITY,
+        name: "Protection Indemnity",
+    },
+    [product.PRODUCT_CODE_STUDENT_PROTECTION]: {
+        value: product.PRODUCT_CODE_STUDENT_PROTECTION,
+        name: "Student Protection",
+    },
+    [product.PRODUCT_CODE_GADGET]: {
+        value: product.PRODUCT_CODE_GADGET,
+        name: "Gadget",
+    },
+    [product.PRODUCT_CODE_ELECTRONIC_EQUIPMENT]: {
+        value: product.PRODUCT_CODE_ELECTRONIC_EQUIPMENT,
+        name: "Electronic Equipment Insurance",
+    },
+    [product.PRODUCT_CODE_CPM]: {
+        value: product.PRODUCT_CODE_CPM,
+        name: "Contractor's Plant and Machinery",
+    },
+    [product.PRODUCT_CODE_CONSTRUCTION_ALLRISK]: {
+        value: product.PRODUCT_CODE_CONSTRUCTION_ALLRISK,
+        name: "Construction All Risk",
+    },
+    [product.PRODUCT_CODE_MERIMEN_CARGO]: {
+        value: product.PRODUCT_CODE_MERIMEN_CARGO,
+        name: "Merimen Cargo",
+    },
+    [product.PRODUCT_CODE_HCI_MOTOR]: {
+        value: product.PRODUCT_CODE_HCI_MOTOR,
+        name: "HCI Santunan Motor",
+    },
+    [product.PRODUCT_CODE_HCP5_DISEASE]: {
+        value: product.PRODUCT_CODE_HCP5_DISEASE,
+        name: "HCP 5 Disease",
+    },
+    [product.PRODUCT_CODE_EXIM]: {
+        value: product.PRODUCT_CODE_EXIM,
+        name: "Polismall EXIM",
+    },
+    [product.PRODUCT_CODE_BDKI_MOTOR]: {
+        value: product.PRODUCT_CODE_BDKI_MOTOR,
+        name: "Polismall BDKI motor",
+    },
+    [product.PRODUCT_CODE_BDKI_RUMAH]: {
+        value: product.PRODUCT_CODE_BDKI_RUMAH,
+        name: "Polismall BDKI rumah",
+    },
+    [product.PRODUCT_CODE_MOVEABLE_ALL_RISK]: {
+        value: product.PRODUCT_CODE_MOVEABLE_ALL_RISK,
+        name: "Polismall Moveable All Risk",
+    },
+    [product.PRODUCT_CODE_SURETY_BOND]: {
+        value: product.PRODUCT_CODE_SURETY_BOND,
+        name: "Surety Bond",
+    },
+    [product.PRODUCT_CODE_ERECTION_ALL_RISK]: {
+        value: product.PRODUCT_CODE_ERECTION_ALL_RISK,
+        name: "Erection All Risk",
+    },
+    [product.PRODUCT_CODE_CARGO_BUNDLE]: {
+        value: product.PRODUCT_CODE_CARGO_BUNDLE,
+        name: "Polismall Cargo Bundle",
+    },
+    [product.PRODUCT_CODE_RETAIL_LOKET_PA]: {
+        value: product.PRODUCT_CODE_RETAIL_LOKET_PA,
+        name: "Polismall Loket Personal Accident",
+    },
+    [product.PRODUCT_CODE_RETAIL_KALOG_CARGO]: {
+        value: product.PRODUCT_CODE_RETAIL_KALOG_CARGO,
+        name: "Polismall Kalog Cargo Retail",
+    },
+    [product.PRODUCT_CODE_RETAIL_POS_CARGO]: {
+        value: product.PRODUCT_CODE_RETAIL_POS_CARGO,
+        name: "Polismall Pos Cargo Retail",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_GP]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_GP,
+        name: "Gamers Protection",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_PLN]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_PLN,
+        name: "OTTO PLN",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_PDAM]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_PDAM,
+        name: "OTTO PDAM",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_SB]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_SB,
+        name: "Merchant Protection Stock",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_FB]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_FB,
+        name: "Merchant Protection Flexas - Flood",
+    },
+    [product.PRODUCT_CODE_OTTO_AUM_FBK]: {
+        value: product.PRODUCT_CODE_OTTO_AUM_FBK,
+        name: "Merchant Protection Flexas - Flood - Burglary",
+    },
+};
+exports.default = product;

package/dist/helpers/addDateTime.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ datetime, addDatetime, type, }: {
+    datetime: number;
+    addDatetime: string;
+    type: string;
+}) => number | null;
+export default _default;

package/dist/helpers/addDateTime.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../constants/config");
+exports.default = ({ datetime, addDatetime, type, }) => {
+    try {
+        switch (type) {
+            case config_1.default.date_time_type_for_days: /** addDatetime = 2 => how many date */
+                return (datetime + (parseInt(addDatetime) * 3600000 * 24));
+            case config_1.default.date_time_type_for_time: /** addDatetime = 18:00:00 => only time */
+                const time = addDatetime.split(':'); // 0->hour, 1->minute, 2->second
+                return (datetime
+                    + (parseInt(time[0]) * 3600000)
+                    + (parseInt(time[1]) * 60000)
+                    + (parseInt(time[2]) * 1000));
+            case config_1.default.date_time_type_for_set_time:
+                const date = new Date(datetime); /** addDatetime = 18:00:00 => only time */
+                const settime = addDatetime.split(':'); // 0->hour, 1->minute, 2->second
+                date.setHours(parseInt(settime[0]));
+                date.setMinutes(parseInt(settime[1]));
+                date.setSeconds(parseInt(settime[2]));
+                return date.getTime();
+            default:
+                return null;
+        }
+    }
+    catch (err) {
+        console.log(`[error] ${err.message}`);
+        return null;
+    }
+};

package/dist/helpers/amountDescription.d.ts

@@ -0,0 +1 @@
+export default function terbilang(value: number): string;

package/dist/helpers/amountDescription.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function terbilang(value) {
+    const satuan = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'delapan', 'sembilan'];
+    const belasan = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'delapan belas', 'sembilan belas'];
+    const puluhan = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'delapan puluh', 'sembilan puluh'];
+    let result = '';
+    if (value < 10) {
+        result = satuan[value];
+    }
+    else if (value < 20) {
+        result = belasan[value - 10];
+    }
+    else if (value < 100) {
+        result = puluhan[Math.floor(value / 10)] + ' ' + satuan[value % 10];
+    }
+    else if (value < 200) {
+        result = 'seratus ' + terbilang(value - 100);
+    }
+    else if (value < 1000) {
+        result = satuan[Math.floor(value / 100)] + ' ratus ' + terbilang(value % 100);
+    }
+    else if (value < 2000) {
+        result = 'seribu ' + terbilang(value - 1000);
+    }
+    else if (value < 1000000) {
+        result = terbilang(Math.floor(value / 1000)) + ' ribu ' + terbilang(value % 1000);
+    }
+    else if (value < 1000000000) {
+        result = terbilang(Math.floor(value / 1000000)) + ' juta ' + terbilang(value % 1000000);
+    }
+    else if (value < 1000000000000) {
+        result = terbilang(Math.floor(value / 1000000000)) + ' milyar ' + terbilang(value % 1000000000);
+    }
+    else if (value < 1000000000000000) {
+        result = terbilang(Math.floor(value / 1000000000000)) + ' triliun ' + terbilang(value % 1000000000000);
+    }
+    else {
+        result = 'Angka terlalu besar';
+    }
+    // Menghilangkan spasi yang double
+    return result.replace(/\s+/g, ' ').trim();
+}
+exports.default = terbilang;

package/dist/helpers/axiosGet.d.ts

@@ -0,0 +1,8 @@
+import IAxios from '../interface/axios.interface';
+declare const _default: ({ url, headers, params, callback, }: {
+    url: string;
+    headers: any;
+    params?: any;
+    callback?: (response: any) => Promise<IAxios<any>>;
+}) => Promise<IAxios<any>>;
+export default _default;

package/dist/helpers/axiosGet.js

@@ -0,0 +1,47 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const generateRelationId_1 = require("./generateRelationId");
+const getCurrentDate_1 = require("./getCurrentDate");
+const constants_1 = require("../constants");
+exports.default = ({ url, headers, params, callback, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield axios_1.default.get(url, {
+        params,
+        headers: Object.assign({ 'Content-Type': 'application/json', 'X-Correlation-Id': (0, generateRelationId_1.default)(24), 'X-Transmission-Date-Time': (0, getCurrentDate_1.default)() }, headers),
+    }).then((result) => __awaiter(void 0, void 0, void 0, function* () {
+        if (result.data.statusCode === constants_1.config.HTTP_STATUS_OK) {
+            if (callback) {
+                return yield callback(result.data).catch((err) => {
+                    console.log(`[error][${(0, getCurrentDate_1.default)()}]. Error: ${err.message}`);
+                    return {
+                        statusCode: constants_1.config.HTTP_STATUS_SERVER_ERROR,
+                        message: err.message,
+                    };
+                });
+            }
+            else {
+                return {
+                    statusCode: result.data.statusCode,
+                    data: result.data.data,
+                };
+            }
+        }
+        else {
+            return {
+                statusCode: result.data.statusCode,
+                message: result.data.message,
+            };
+        }
+    })).catch((err) => {
+        throw new Error(err);
+    });
+});

package/dist/helpers/axiosPost.d.ts

@@ -0,0 +1,8 @@
+import IAxios from '../interface/axios.interface';
+declare const _default: ({ url, headers, body, callback, }: {
+    url: string;
+    headers: any;
+    body: any;
+    callback?: (response: any) => Promise<IAxios<any>>;
+}) => Promise<IAxios<any>>;
+export default _default;

package/dist/helpers/axiosPost.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const generateRelationId_1 = require("./generateRelationId");
+const getCurrentDate_1 = require("./getCurrentDate");
+const constants_1 = require("../constants");
+exports.default = ({ url, headers, body, callback, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield axios_1.default.post(url, body, {
+        headers: Object.assign({ 'Content-Type': 'application/json', 'X-Correlation-Id': (0, generateRelationId_1.default)(24), 'X-Transmission-Date-Time': (0, getCurrentDate_1.default)() }, headers),
+    }).then((result) => __awaiter(void 0, void 0, void 0, function* () {
+        if (result.data.statusCode === constants_1.config.HTTP_STATUS_OK) {
+            if (callback) {
+                return yield callback(result.data).catch((err) => {
+                    console.log(`[error][${(0, getCurrentDate_1.default)()}]. Error: ${err.message}`);
+                    return {
+                        statusCode: constants_1.config.HTTP_STATUS_SERVER_ERROR,
+                        message: err.message,
+                    };
+                });
+            }
+            else {
+                return {
+                    statusCode: result.data.statusCode,
+                    data: result.data.data,
+                };
+            }
+        }
+        else {
+            return {
+                statusCode: result.data.statusCode,
+                message: result.data.message,
+            };
+        }
+    })).catch((err) => {
+        throw new Error(err);
+    });
+});

package/dist/helpers/axiosPut.d.ts

@@ -0,0 +1,8 @@
+import IAxios from '../interface/axios.interface';
+declare const _default: ({ url, headers, body, callback, }: {
+    url: string;
+    headers: any;
+    body: any;
+    callback?: (response: any) => Promise<IAxios<any>>;
+}) => Promise<IAxios<any>>;
+export default _default;

package/dist/helpers/axiosPut.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const constants_1 = require("../constants");
+const generateRelationId_1 = require("./generateRelationId");
+const getCurrentDate_1 = require("./getCurrentDate");
+exports.default = ({ url, headers, body, callback, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield axios_1.default.put(url, body, {
+        headers: Object.assign({ 'Content-Type': 'application/json', 'X-Correlation-Id': (0, generateRelationId_1.default)(24), 'X-Transmission-Date-Time': (0, getCurrentDate_1.default)() }, headers),
+    }).then((result) => __awaiter(void 0, void 0, void 0, function* () {
+        if (result.data.statusCode === constants_1.config.HTTP_STATUS_OK) {
+            if (callback) {
+                return yield callback(result.data).catch((err) => {
+                    console.log(`[error][${(0, getCurrentDate_1.default)()}]. Error: ${err.message}`);
+                    return {
+                        statusCode: constants_1.config.HTTP_STATUS_SERVER_ERROR,
+                        message: err.message,
+                    };
+                });
+            }
+            else {
+                return {
+                    statusCode: result.data.statusCode,
+                    data: result.data.data,
+                };
+            }
+        }
+        else {
+            return {
+                statusCode: result.data.statusCode,
+                message: result.data.message,
+            };
+        }
+    })).catch((err) => {
+        throw new Error(err);
+    });
+});

package/dist/helpers/compareDiffObj.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (oldObj: any, newObj: any) => any;
+export default _default;

package/dist/helpers/compareDiffObj.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+exports.default = (oldObj, newObj) => {
+    return [...Object.keys(newObj), ...Object.keys(oldObj)].reduce((arr, key) => {
+        if (newObj[key] === undefined)
+            return Object.assign(Object.assign({}, arr), { [key]: oldObj[key] });
+        if (oldObj[key] === undefined)
+            return Object.assign(Object.assign({}, arr), { [key]: newObj[key] });
+        if (oldObj[key] != newObj[key])
+            return Object.assign(Object.assign({}, arr), { [key]: oldObj[key] });
+        return arr;
+    }, {});
+};

package/dist/helpers/convertCurrencySymbol.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (currencyCode: string) => string | null;
+export default _default;

package/dist/helpers/convertCurrencySymbol.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getCurrentDate_1 = require("./getCurrentDate");
+const currency_1 = require("../constants/currency");
+exports.default = (currencyCode) => {
+    try {
+        switch (currencyCode) {
+            case currency_1.default.CURRENCY_IDR:
+                return 'Rp.';
+            case currency_1.default.CURRENCY_USD:
+                return '$';
+            default:
+                throw new Error(`this currency code ${currencyCode}  is not found`);
+        }
+    }
+    catch (err) {
+        console.log(`[error][${(0, getCurrentDate_1.default)()}] Convert to currency error: ${err.message}`);
+        return '-';
+    }
+};