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

package/build/@types/user.js

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

package/build/api/account.d.ts

@@ -0,0 +1,26 @@
+import { PaymentProvider, SDKNotification } from '../@types';
+export declare type CreateAccountBody = {
+    lead_id: string;
+    notify: {
+        email: boolean;
+        phone: boolean;
+    };
+    skip_legacy: boolean;
+    is_acknowledged: boolean;
+    step_name: string;
+};
+export declare type ExpressCreateAccountBody = {
+    post_url: string;
+    lead_id: string;
+    platforms?: string[];
+    payment_provider?: PaymentProvider;
+    notification?: SDKNotification;
+};
+declare const 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>;
+};
+export { accountService };

package/build/api/account.js

@@ -0,0 +1,42 @@
+import { ENDPOINT_PATHS } from '../constants';
+import { httpClient } from './axios';
+var createAccount = function (data) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.CREATE_ACCOUNT,
+        data: data
+    });
+};
+var expressCreateAccount = function (data) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.EXPRESS_CREATE_ACCOUNT,
+        data: data
+    });
+};
+var checkAccountAvailability = function (individualId) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(individualId, "/accounts")
+    });
+};
+var checkAccountAvailabilityStatus = function (individualId) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(individualId, "/accounts?data=status")
+    });
+};
+var checkMigrationStatus = function (jobId) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.MIGRATION_STATUS, "/").concat(jobId)
+    });
+};
+var accountService = {
+    createAccount: createAccount,
+    expressCreateAccount: expressCreateAccount,
+    checkAccountAvailability: checkAccountAvailability,
+    checkAccountAvailabilityStatus: checkAccountAvailabilityStatus,
+    checkMigrationStatus: checkMigrationStatus
+};
+export { accountService };

package/build/api/auth.d.ts

@@ -0,0 +1,150 @@
+import { AxiosRequestConfig } from 'axios';
+import { ConfigInfo, LanguageMode } from '../@types';
+export declare type MobileCredential = {
+    code: string;
+    phone: string;
+};
+export declare type EmailCredential = {
+    email: string;
+};
+export declare type IDCredential = {
+    country_code?: string;
+    identification_id: string;
+    identification_id_type?: string;
+    date_of_birth?: string;
+};
+export declare type CivilID = {
+    identification_id: string;
+    country_code: string;
+};
+export declare type TerminalCredential = {
+    terminal?: {
+        id: string;
+        terminal_device?: {
+            id: string;
+        };
+    };
+    merchant?: {
+        id: string;
+    };
+    device: {
+        id: string;
+    };
+};
+export declare type CreateAuthBody = {
+    country: string;
+    scope: string;
+    user_credentail: MobileCredential | EmailCredential | IDCredential | CivilID | TerminalCredential;
+    auth_type?: number;
+    email_url?: string;
+    sign_in?: boolean;
+    is_lead?: boolean;
+    step_name?: string;
+    encryption_contract: Array<string>;
+    lang?: LanguageMode;
+    lead_id?: string;
+    board_id?: string;
+    user_id?: string;
+    login?: boolean;
+};
+export declare type CreateNafathAuthBody = {
+    country: string;
+    scope: string;
+    user_credentail: IDCredential;
+    auth_type?: number;
+    email_url?: string;
+    sign_in?: boolean;
+    is_lead?: boolean;
+    step_name?: string;
+    encryption_contract: Array<string>;
+    lang?: LanguageMode;
+    lead_id?: string;
+    board_id?: string;
+    user_id?: string;
+};
+export declare type CreateKYCAuthBody = {
+    country: string;
+    scope: string;
+    auth_type?: number;
+    email_url?: string;
+    sign_in?: boolean;
+    is_lead?: boolean;
+    step_name?: string;
+    encryption_contract: Array<string>;
+    lang?: LanguageMode;
+    lead_id?: string;
+    board_id?: string;
+    user_id?: string;
+};
+export declare type VerifyAuthBody = {
+    auth_token: string;
+    auth_type: number;
+    data: string;
+    device_token: string;
+    step_name: string;
+    service_name: string;
+    new_user?: boolean;
+    sign_in: boolean;
+    is_lead?: boolean;
+    encryption_contract: Array<string>;
+    remember_me?: boolean;
+    lead_id?: string;
+    terms?: Array<string>;
+};
+export declare type VerifyOperationAuthBody = {
+    auth_token: string;
+    auth_type: number;
+};
+export declare type ResetPasswordCredential = {
+    otp: string;
+    new_password: string;
+};
+export declare type ResetPasswordVerifyAuthBody = {
+    auth_token: string;
+    auth_type: number;
+    step_name: string;
+    user_credentail: ResetPasswordCredential;
+    encryption_contract: Array<string>;
+};
+export declare type CreatePasswordBody = {
+    password: string;
+    signup_token?: string;
+    step_name: string;
+    encryption_contract: Array<string>;
+};
+export declare 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>;
+};
+export declare type getExpressTokenVerifyParams = {
+    token: string;
+    leadId: string;
+};
+export declare type ConfigBody = Pick<ConfigInfo, 'scope' | 'data' | 'lead' | 'board' | 'interface' | 'redirect' | 'post'>;
+declare const authService: {
+    createAuth: (data: CreateAuthBody | CreateKYCAuthBody, 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>;
+    getVerifyExpressAuth: (token: string, config?: AxiosRequestConfig) => Promise<any>;
+    getExpressTokenVerify: ({ token, leadId }: getExpressTokenVerifyParams, config?: AxiosRequestConfig) => Promise<any>;
+    generateConfigToken: (body: ConfigBody) => Promise<any>;
+};
+export { authService };

package/build/api/auth.js

@@ -0,0 +1,93 @@
+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 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);
+};
+var createPassword = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.SIGNUP),
+        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 getVerifyExpressAuth = function (token, config) {
+    return httpClient(__assign({ method: 'get', url: "".concat(ENDPOINT_PATHS.Verify_Express_Auth_PACI_PATH, "/").concat(token) }, config));
+};
+var getExpressTokenVerify = function (_a, config) {
+    var token = _a.token, leadId = _a.leadId;
+    return httpClient(__assign({ method: 'get', url: "".concat(ENDPOINT_PATHS.EXPRESS_PATH, "/").concat(leadId).concat(ENDPOINT_PATHS.TOKEN_VERIFY, "/").concat(token) }, config));
+};
+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 generateConfigToken = function (body) {
+    return httpClient({
+        method: 'post',
+        url: ENDPOINT_PATHS.CREATE_CONNECT,
+        data: body
+    });
+};
+var authService = {
+    createAuth: createAuth,
+    verifyAuth: verifyAuth,
+    createPassword: createPassword,
+    verifyExpressAuth: verifyExpressAuth,
+    getVerifyAuth: getVerifyAuth,
+    getTokenVerify: getTokenVerify,
+    createAuthKitNID: createAuthKitNID,
+    createExpressAuth: createExpressAuth,
+    verifyExpressLeadIdentity: verifyExpressLeadIdentity,
+    createExpressLeadIdentityAuth: createExpressLeadIdentityAuth,
+    getVerifyExpressAuth: getVerifyExpressAuth,
+    getExpressTokenVerify: getExpressTokenVerify,
+    generateConfigToken: generateConfigToken
+};
+export { authService };

package/build/api/availabilityServices.d.ts

@@ -0,0 +1,21 @@
+import { AxiosRequestConfig } from 'axios';
+export declare type CheckEmailBody = {
+    email: string | null;
+    country: string;
+    encryption_contract: Array<string>;
+};
+export declare type CheckBrandBody = {
+    profile_name: string;
+    country_code: string;
+    encryption_contract: Array<string>;
+};
+export declare type CheckIBanBody = {
+    iban_number: string;
+    encryption_contract?: Array<string>;
+};
+declare const availabilityServices: {
+    checkEmail: (data: CheckEmailBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    checkBrand: (data: CheckBrandBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+    checkIbanBank: (data: CheckIBanBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+};
+export default availabilityServices;

package/build/api/availabilityServices.js

@@ -0,0 +1,17 @@
+import instance from './axios';
+import { ENDPOINT_PATHS } from '../constants';
+var checkEmail = function (data, config) {
+    return instance.post("".concat(ENDPOINT_PATHS.CHECK_EMAIL), data, config);
+};
+var checkBrand = function (data, config) {
+    return instance.post("".concat(ENDPOINT_PATHS.CHECK_BRAND), data, config);
+};
+var checkIbanBank = function (data, config) {
+    return instance.post("".concat(ENDPOINT_PATHS.IBAN_BANK), data, config);
+};
+var availabilityServices = {
+    checkEmail: checkEmail,
+    checkBrand: checkBrand,
+    checkIbanBank: checkIbanBank
+};
+export default availabilityServices;

package/build/api/axios.d.ts

@@ -0,0 +1,7 @@
+import { AxiosRequestConfig } from 'axios';
+declare const instance: import("axios").AxiosInstance;
+export declare const setAxiosGlobalHeaders: (headers: Record<string, string>) => void;
+export declare const removeAxiosGlobalHeaders: (arr: Array<string>) => void;
+export declare const getAxiosHeaders: () => Record<string, any>;
+export declare const httpClient: (config: AxiosRequestConfig) => Promise<any>;
+export default instance;

package/build/api/axios.js

@@ -0,0 +1,110 @@
+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 axios from 'axios';
+import { get, set } from 'lodash-es';
+import { ENCRYPTION_FLAG } from '../constants';
+import { encryptString } from '../utils';
+var instance = axios.create({
+    headers: {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Headers': true
+    }
+});
+instance.interceptors.request.use(function (config) {
+    return encryptionContractTransformer(config);
+}, function (error) { return Promise.reject(error); });
+instance.interceptors.response.use(function (response) { return response; }, function (error) {
+    return Promise.reject(error);
+});
+var encryptionContractTransformer = function (config) {
+    var _a;
+    var data = config.data;
+    if ((_a = data === null || data === void 0 ? void 0 : data[ENCRYPTION_FLAG]) === null || _a === void 0 ? void 0 : _a.length) {
+        data[ENCRYPTION_FLAG].forEach(function (key) {
+            var value = get(data, key);
+            if (value && typeof value !== 'string') {
+                value = value.toString();
+            }
+            if (value)
+                set(data, key, encryptString(value));
+        });
+        config.data = data;
+    }
+    return config;
+};
+export var setAxiosGlobalHeaders = function (headers) {
+    Object.keys(headers).forEach(function (key) {
+        instance.defaults.headers.common[key] = headers[key];
+        axios.defaults.headers.common[key] = headers[key];
+    });
+};
+export var removeAxiosGlobalHeaders = function (arr) {
+    arr.forEach(function (key) {
+        delete instance.defaults.headers.common[key];
+        delete axios.defaults.headers.common[key];
+    });
+};
+export var getAxiosHeaders = function () {
+    return instance.defaults.headers.common;
+};
+export var httpClient = function (config) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, _a, description, error, err_1, response, message, data, _b, description, error;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                return [4, instance(config)];
+            case 1:
+                data = (_c.sent()).data;
+                _a = (data.errors || [{}])[0], description = _a.description, error = _a.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:
+                err_1 = _c.sent();
+                response = err_1.response, message = err_1.message;
+                data = (response || {}).data;
+                if (typeof data === 'string')
+                    throw new Error(data);
+                _b = ((data === null || data === void 0 ? void 0 : data.errors) || [{}])[0], description = _b.description, error = _b.error;
+                throw new Error(description || error || message || 'Internal server error');
+            case 3: return [2];
+        }
+    });
+}); };
+export default instance;

package/build/api/board.d.ts

@@ -0,0 +1,43 @@
+export declare type UpdateBoardBody = {
+    id?: string;
+    infoId?: string;
+    step_name: string;
+    lang: string;
+    encryption_contract?: string;
+};
+export declare type RetrieveBoardInfoBody = {
+    id: string;
+    infoId: string;
+};
+export declare 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

@@ -0,0 +1,72 @@
+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 retrieveBoardInfo = function (_a) {
+    var id = _a.id, infoId = _a.infoId;
+    return httpClient({
+        method: 'get',
+        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',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id)
+    });
+};
+var retrieveBoardDetails = function (id) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id, "/details")
+    });
+};
+var updateBoard = function (_a) {
+    var id = _a.id, data = __rest(_a, ["id"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id),
+        data: data
+    });
+};
+var updateBoardInfo = function (_a) {
+    var id = _a.id, infoId = _a.infoId, data = __rest(_a, ["id", "infoId"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.BOARD, "/").concat(id, "/info/collect/").concat(infoId),
+        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,
+    retrieveBoardInfoStatus: retrieveBoardInfoStatus,
+    requestDetailsByEmail: requestDetailsByEmail
+};
+export { boardService };

package/build/api/brand.d.ts

@@ -0,0 +1,16 @@
+import { BrandListBody, UpdateBrandBody, UpdateSalesChannels } from '../api/individual';
+export declare type RemoveBrandActivity = {
+    id: string;
+    activities?: Array<{
+        id: string;
+    }>;
+};
+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>;
+    removeBrandActivity: ({ id, ...data }: RemoveBrandActivity) => Promise<any>;
+};
+export { brandService };

package/build/api/brand.js

@@ -0,0 +1,66 @@
+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 { httpClient } from './axios';
+import { ENDPOINT_PATHS } from '../constants';
+var retrieveBrand = function (id) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.BRAND, "/").concat(id)
+    });
+};
+var getBrandList = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.BRAND_LIST),
+        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({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.BRAND, "/").concat(id),
+        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 removeBrandActivity = function (_a) {
+    var id = _a.id, data = __rest(_a, ["id"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.BRAND, "/").concat(id, "/activities/remove"),
+        data: data
+    });
+};
+var brandService = {
+    retrieveBrand: retrieveBrand,
+    getBrandList: getBrandList,
+    updateBrandInfo: updateBrandInfo,
+    updateBrandSales: updateBrandSales,
+    getBrandListByIndividualId: getBrandListByIndividualId,
+    removeBrandActivity: removeBrandActivity
+};
+export { brandService };