storemw-core-client 1.0.1

package/dist/services/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountService = exports.transportTypes = exports.logisticTargetTypes = exports.logisticTypes = exports.LogisticService = exports.businessTargetTypes = exports.businessTypes = exports.BusinessService = exports.transactionActionTypes = exports.transactionTargetTypes = exports.transactionTypes = exports.TransactionService = exports.walletCurrencyTypes = exports.walletTargetTypes = exports.walletTypes = exports.WalletService = exports.rateCalculationTypes = exports.rateTargetTypes = exports.rateTypes = exports.RateService = exports.regionTargetTypes = exports.regionTypes = exports.RegionService = exports.locationTargetTypes = exports.locationTypes = exports.LocationService = exports.getInjectionFieldsPayload = exports.injectionFieldDataTypes = exports.injectionFieldScopeTypes = exports.injectionFieldMap = exports.InjectionFieldService = exports.itemTargetTypes = exports.itemTypes = exports.ItemService = exports.documentTypes = exports.DocumentService = exports.branchTargetTypes = exports.branchTypes = exports.BranchService = exports.branchUserTargetTypes = exports.branchUserTypes = exports.BranchUserService = exports.roleTargetTypes = exports.roleTypes = exports.UserRoleService = exports.userTargetTypes = exports.userTypes = exports.UserService = exports.authTargetTypes = exports.AuthService = void 0;
+exports.permissionFunctionActionTypes = exports.permissionFunctionTypes = exports.permissionModuleTypes = exports.permissionScopeTypes = exports.permissionTypes = exports.PermissionService = exports.repositoryTargetTypes = exports.repositoryTypes = exports.RepositoryService = exports.accountTargetTypes = exports.accountTypes = void 0;
+var AuthService_1 = require("../services/auth/AuthService");
+Object.defineProperty(exports, "AuthService", { enumerable: true, get: function () { return AuthService_1.AuthService; } });
+Object.defineProperty(exports, "authTargetTypes", { enumerable: true, get: function () { return AuthService_1.authTargetTypes; } });
+var UserService_1 = require("../services/user/UserService");
+Object.defineProperty(exports, "UserService", { enumerable: true, get: function () { return UserService_1.UserService; } });
+Object.defineProperty(exports, "userTypes", { enumerable: true, get: function () { return UserService_1.userTypes; } });
+Object.defineProperty(exports, "userTargetTypes", { enumerable: true, get: function () { return UserService_1.userTargetTypes; } });
+var UserRoleService_1 = require("../services/user/UserRoleService");
+Object.defineProperty(exports, "UserRoleService", { enumerable: true, get: function () { return UserRoleService_1.UserRoleService; } });
+Object.defineProperty(exports, "roleTypes", { enumerable: true, get: function () { return UserRoleService_1.roleTypes; } });
+Object.defineProperty(exports, "roleTargetTypes", { enumerable: true, get: function () { return UserRoleService_1.roleTargetTypes; } });
+var BranchUserService_1 = require("../services/user/BranchUserService");
+Object.defineProperty(exports, "BranchUserService", { enumerable: true, get: function () { return BranchUserService_1.BranchUserService; } });
+Object.defineProperty(exports, "branchUserTypes", { enumerable: true, get: function () { return BranchUserService_1.branchUserTypes; } });
+Object.defineProperty(exports, "branchUserTargetTypes", { enumerable: true, get: function () { return BranchUserService_1.branchUserTargetTypes; } });
+var BranchService_1 = require("../services/branch/BranchService");
+Object.defineProperty(exports, "BranchService", { enumerable: true, get: function () { return BranchService_1.BranchService; } });
+Object.defineProperty(exports, "branchTypes", { enumerable: true, get: function () { return BranchService_1.branchTypes; } });
+Object.defineProperty(exports, "branchTargetTypes", { enumerable: true, get: function () { return BranchService_1.branchTargetTypes; } });
+var DocumentService_1 = require("../services/document/DocumentService");
+Object.defineProperty(exports, "DocumentService", { enumerable: true, get: function () { return DocumentService_1.DocumentService; } });
+Object.defineProperty(exports, "documentTypes", { enumerable: true, get: function () { return DocumentService_1.documentTypes; } });
+var ItemService_1 = require("../services/item/ItemService");
+Object.defineProperty(exports, "ItemService", { enumerable: true, get: function () { return ItemService_1.ItemService; } });
+Object.defineProperty(exports, "itemTypes", { enumerable: true, get: function () { return ItemService_1.itemTypes; } });
+Object.defineProperty(exports, "itemTargetTypes", { enumerable: true, get: function () { return ItemService_1.itemTargetTypes; } });
+var InjectionFieldService_1 = require("../services/injection_field/InjectionFieldService");
+Object.defineProperty(exports, "InjectionFieldService", { enumerable: true, get: function () { return InjectionFieldService_1.InjectionFieldService; } });
+Object.defineProperty(exports, "injectionFieldMap", { enumerable: true, get: function () { return InjectionFieldService_1.injectionFieldMap; } });
+Object.defineProperty(exports, "injectionFieldScopeTypes", { enumerable: true, get: function () { return InjectionFieldService_1.injectionFieldScopeTypes; } });
+Object.defineProperty(exports, "injectionFieldDataTypes", { enumerable: true, get: function () { return InjectionFieldService_1.injectionFieldDataTypes; } });
+Object.defineProperty(exports, "getInjectionFieldsPayload", { enumerable: true, get: function () { return InjectionFieldService_1.getInjectionFieldsPayload; } });
+var LocationService_1 = require("../services/location/LocationService");
+Object.defineProperty(exports, "LocationService", { enumerable: true, get: function () { return LocationService_1.LocationService; } });
+Object.defineProperty(exports, "locationTypes", { enumerable: true, get: function () { return LocationService_1.locationTypes; } });
+Object.defineProperty(exports, "locationTargetTypes", { enumerable: true, get: function () { return LocationService_1.locationTargetTypes; } });
+var RegionService_1 = require("../services/region/RegionService");
+Object.defineProperty(exports, "RegionService", { enumerable: true, get: function () { return RegionService_1.RegionService; } });
+Object.defineProperty(exports, "regionTypes", { enumerable: true, get: function () { return RegionService_1.regionTypes; } });
+Object.defineProperty(exports, "regionTargetTypes", { enumerable: true, get: function () { return RegionService_1.regionTargetTypes; } });
+var RateService_1 = require("../services/rate/RateService");
+Object.defineProperty(exports, "RateService", { enumerable: true, get: function () { return RateService_1.RateService; } });
+Object.defineProperty(exports, "rateTypes", { enumerable: true, get: function () { return RateService_1.rateTypes; } });
+Object.defineProperty(exports, "rateTargetTypes", { enumerable: true, get: function () { return RateService_1.rateTargetTypes; } });
+Object.defineProperty(exports, "rateCalculationTypes", { enumerable: true, get: function () { return RateService_1.rateCalculationTypes; } });
+var WalletService_1 = require("../services/wallet/WalletService");
+Object.defineProperty(exports, "WalletService", { enumerable: true, get: function () { return WalletService_1.WalletService; } });
+Object.defineProperty(exports, "walletTypes", { enumerable: true, get: function () { return WalletService_1.walletTypes; } });
+Object.defineProperty(exports, "walletTargetTypes", { enumerable: true, get: function () { return WalletService_1.walletTargetTypes; } });
+Object.defineProperty(exports, "walletCurrencyTypes", { enumerable: true, get: function () { return WalletService_1.walletCurrencyTypes; } });
+var TransactionService_1 = require("../services/transaction/TransactionService");
+Object.defineProperty(exports, "TransactionService", { enumerable: true, get: function () { return TransactionService_1.TransactionService; } });
+Object.defineProperty(exports, "transactionTypes", { enumerable: true, get: function () { return TransactionService_1.transactionTypes; } });
+Object.defineProperty(exports, "transactionTargetTypes", { enumerable: true, get: function () { return TransactionService_1.transactionTargetTypes; } });
+Object.defineProperty(exports, "transactionActionTypes", { enumerable: true, get: function () { return TransactionService_1.transactionActionTypes; } });
+var BusinessService_1 = require("../services/business/BusinessService");
+Object.defineProperty(exports, "BusinessService", { enumerable: true, get: function () { return BusinessService_1.BusinessService; } });
+Object.defineProperty(exports, "businessTypes", { enumerable: true, get: function () { return BusinessService_1.businessTypes; } });
+Object.defineProperty(exports, "businessTargetTypes", { enumerable: true, get: function () { return BusinessService_1.businessTargetTypes; } });
+var LogisticService_1 = require("../services/logistic/LogisticService");
+Object.defineProperty(exports, "LogisticService", { enumerable: true, get: function () { return LogisticService_1.LogisticService; } });
+Object.defineProperty(exports, "logisticTypes", { enumerable: true, get: function () { return LogisticService_1.logisticTypes; } });
+Object.defineProperty(exports, "logisticTargetTypes", { enumerable: true, get: function () { return LogisticService_1.logisticTargetTypes; } });
+Object.defineProperty(exports, "transportTypes", { enumerable: true, get: function () { return LogisticService_1.transportTypes; } });
+var AccountService_1 = require("../services/account/AccountService");
+Object.defineProperty(exports, "AccountService", { enumerable: true, get: function () { return AccountService_1.AccountService; } });
+Object.defineProperty(exports, "accountTypes", { enumerable: true, get: function () { return AccountService_1.accountTypes; } });
+Object.defineProperty(exports, "accountTargetTypes", { enumerable: true, get: function () { return AccountService_1.accountTargetTypes; } });
+var RepositoryService_1 = require("../services/repository/RepositoryService");
+Object.defineProperty(exports, "RepositoryService", { enumerable: true, get: function () { return RepositoryService_1.RepositoryService; } });
+Object.defineProperty(exports, "repositoryTypes", { enumerable: true, get: function () { return RepositoryService_1.repositoryTypes; } });
+Object.defineProperty(exports, "repositoryTargetTypes", { enumerable: true, get: function () { return RepositoryService_1.repositoryTargetTypes; } });
+var PermissionService_1 = require("../services/permission/PermissionService");
+Object.defineProperty(exports, "PermissionService", { enumerable: true, get: function () { return PermissionService_1.PermissionService; } });
+Object.defineProperty(exports, "permissionTypes", { enumerable: true, get: function () { return PermissionService_1.permissionTypes; } });
+Object.defineProperty(exports, "permissionScopeTypes", { enumerable: true, get: function () { return PermissionService_1.permissionScopeTypes; } });
+Object.defineProperty(exports, "permissionModuleTypes", { enumerable: true, get: function () { return PermissionService_1.permissionModuleTypes; } });
+Object.defineProperty(exports, "permissionFunctionTypes", { enumerable: true, get: function () { return PermissionService_1.permissionFunctionTypes; } });
+Object.defineProperty(exports, "permissionFunctionActionTypes", { enumerable: true, get: function () { return PermissionService_1.permissionFunctionActionTypes; } });
+// export { SessionService } from './SessionService';
+// export { StorageService } from '../StorageService';
+// export { UserService, userTypes, targetTypes as userTargetTypes } from './UserService';
+// export type { UserType, UserTargetType } from "./UserService"
+// export { AccountingActivityService } from './AccountingActivityService';
+// export type { AccountingActivityModuleType } from './AccountingActivityService';
+// export { DocumentService, documentTypes } from './DocumentService';
+// export type { DocumentType } from './DocumentService';
+// export { MarkingService } from './MarkingService';
+// export { AgentService } from './AgentService';
+// export { filterOperatorTypes } from "../utils/buildApiParams";
+// export type { BuildApiListParamsProps, BuildApiGetParamsProps } from "../utils/buildApiParams";
+// export { AutocountDocumentService, AutocountDocumentTypes } from './AutocountDocumentService';
+// export type { AutocountDocumentServiceCreateProps, AutocountDocumentServiceCancelProps, AutocountDocumentServiceListProps, AutocountDocumentServiceGetProps, AutocountDocumentType } from './AutocountDocumentService';

package/dist/services/injection_field/InjectionFieldService.d.ts

@@ -0,0 +1,113 @@
+import { ApiServiceType } from '@/lib';
+import { BuildApiListParamsProps, BuildApiGetParamsProps } from '@/lib';
+export type InjectionFieldDataTypeValueMap = {
+    id: number;
+    text: string;
+    value: string;
+    numeric: number;
+    integer: number;
+    timestamp: string;
+    date: string;
+    date_time: string;
+};
+export declare const injectionFieldDataTypes: Record<keyof InjectionFieldDataTypeValueMap, any>;
+type InjectionFieldDataTypeId = keyof InjectionFieldDataTypeValueMap;
+type InferValues<T extends Record<string, InjectionField>> = {
+    [K in keyof T]?: InjectionFieldDataTypeValueMap[T[K]["fieldDataTypeId"]];
+};
+export type InjectionFieldScopeType = "item" | "document" | "document_item" | "repository" | "repository_item" | "user" | "branch" | "branch_user" | "logistic";
+type ScopeTypeMeta = {
+    id: string;
+    key: string;
+    description: string;
+};
+type ScopeTypeMap = {
+    [K in InjectionFieldScopeType]: ScopeTypeMeta;
+};
+export declare const injectionFieldScopeTypes: ScopeTypeMap;
+type InjectionFieldMeta = {
+    rootKey: string;
+    module: string;
+    key: string;
+};
+type InjectionFieldMap = {
+    [K in InjectionFieldScopeType]: InjectionFieldMeta[];
+};
+export declare const injectionFieldMap: InjectionFieldMap;
+export type InjectionField = {
+    fieldKey: string;
+    retrieveKey: string;
+    fieldDataTypeId: InjectionFieldDataTypeId;
+} & StrictInjectionField;
+type MainOptionsMap = typeof injectionFieldMap;
+type Option<T extends InjectionFieldScopeType> = MainOptionsMap[T][number];
+type Module<T extends InjectionFieldScopeType> = Option<T>["module"];
+type InjectionFieldBase = {
+    fieldKey: string;
+};
+type GenericInjectionField<T extends InjectionFieldScopeType> = InjectionFieldBase & {
+    fieldRef: T;
+    fieldModule: Module<T>;
+};
+export type StrictInjectionField = GenericInjectionField<"document"> | GenericInjectionField<"document_item"> | GenericInjectionField<"item"> | GenericInjectionField<"repository"> | GenericInjectionField<"repository_item"> | GenericInjectionField<"logistic"> | GenericInjectionField<"user"> | GenericInjectionField<"branch"> | GenericInjectionField<"branch_user">;
+export type InjectionFieldServiceProps<T extends InjectionFieldScopeType = InjectionFieldScopeType> = ApiServiceType & {
+    scopeType?: T;
+};
+export type ListInjectionFieldProps = BuildApiListParamsProps & {};
+export type GetInjectionFieldProps = BuildApiGetParamsProps & {
+    id: number | string;
+};
+export type CreateInjectionFieldProps = {
+    scopeType?: InjectionFieldScopeType;
+    data: (StrictInjectionField & {
+        fieldType: InjectionFieldDataTypeValueMap;
+    })[];
+};
+export type UpdateInjectionFieldValuesProps = {
+    scopeType?: InjectionFieldScopeType;
+    data: any[];
+};
+export type RemoveInjectionFieldProps = {
+    ids: number[];
+};
+export declare function getInjectionFieldsPayload<T extends Record<string, InjectionField>>({ referId, injectionFields, values, }: {
+    referId: number;
+    injectionFields: T;
+    values: InferValues<T>;
+}): {
+    refId: number;
+    fieldRef: "document" | "user" | "repository" | "logistic" | "item" | "branch_user" | "document_item" | "repository_item" | "branch";
+    fieldKey: string;
+    fieldModule: string;
+    value: any;
+}[];
+export declare const InjectionFieldService: <T extends InjectionFieldScopeType>(props: InjectionFieldServiceProps<T>) => {
+    list: (props: ListInjectionFieldProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    get: (props: GetInjectionFieldProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    create: (props: CreateInjectionFieldProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    remove: ({ ids }: RemoveInjectionFieldProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    updateInjectionFieldValues: (props: UpdateInjectionFieldValuesProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    getInjectionFieldScopeTypes: () => ScopeTypeMap;
+    getInjectionFieldModulesByScopeType: (scopeType: InjectionFieldScopeType) => InjectionFieldMeta[];
+};
+export {};

package/dist/services/injection_field/InjectionFieldService.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionFieldService = exports.injectionFieldMap = exports.injectionFieldScopeTypes = exports.injectionFieldDataTypes = void 0;
+exports.getInjectionFieldsPayload = getInjectionFieldsPayload;
+const lib_1 = require("@/lib");
+const lib_2 = require("@/lib");
+exports.injectionFieldDataTypes = {
+    id: { id: "id", fieldName: "field_id" },
+    text: { id: "text", fieldName: "field_text" },
+    value: { id: "value", fieldName: "field_value" },
+    numeric: { id: "numeric", fieldName: "field_numeric" },
+    integer: { id: "integer", fieldName: "field_integer" },
+    timestamp: { id: "timestamp", fieldName: "field_timestamp" },
+    date: { id: "date", fieldName: "field_date" },
+    date_time: { id: "date_time", fieldName: "field_date_time" },
+};
+exports.injectionFieldScopeTypes = {
+    item: { id: "item", key: "", description: "Support product, item, category, etc" },
+    document: { id: "document", key: "doc", description: "Support document, document_item, etc" },
+    document_item: { id: "document_item", key: "doci", description: "Subset from document" },
+    repository: { id: "repository", key: "", description: "Support repository, package, etc" },
+    repository_item: { id: "repository_item", key: "", description: "Support container, package, etc" },
+    user: { id: "user", key: "", description: "Support customer, retailer, branch, branch_user, etc" },
+    branch: { id: "branch", key: "", description: "Support customer, retailer branches" },
+    branch_user: { id: "branch_user", key: "", description: "Support branch users" },
+    logistic: { id: "logistic", key: "", description: "Support transporter, etc" },
+};
+exports.injectionFieldMap = {
+    item: [
+        { rootKey: "itm", module: "product", key: "prt" },
+        { rootKey: "itm", module: "item", key: "itm" },
+        { rootKey: "itm", module: "brand", key: "brd" },
+        { rootKey: "itm", module: "category", key: "ct" },
+        { rootKey: "itm", module: "item_uom", key: "uom" },
+    ],
+    document: [
+        { rootKey: "doc", module: "delivery", key: "do" },
+        { rootKey: "doc", module: "cash_sales", key: "cs" },
+        { rootKey: "doc", module: "sales", key: "so" },
+        { rootKey: "doc", module: "proforma_sales", key: "pso" },
+        { rootKey: "doc", module: "retail_cash_sales", key: "rcs" },
+        { rootKey: "doc", module: "replacement_delivery", key: "rdo" },
+    ],
+    document_item: [
+        { rootKey: "doci", module: "delivery", key: "do" },
+        { rootKey: "doci", module: "cash_sales", key: "cs" },
+        { rootKey: "doci", module: "sales", key: "so" },
+        { rootKey: "doci", module: "proforma_sales", key: "pso" },
+        { rootKey: "doci", module: "retail_cash_sales", key: "rcs" },
+        { rootKey: "doci", module: "replacement_delivery", key: "rdo" },
+    ],
+    repository: [
+        { rootKey: "repo", module: "package", key: "pk" },
+        { rootKey: "repo", module: "container", key: "cont" },
+    ],
+    repository_item: [
+        { rootKey: "repo_item", module: "package", key: "pk" },
+        { rootKey: "repo_item", module: "container", key: "cont" },
+    ],
+    logistic: [
+        { rootKey: "lgt", module: "transporter", key: "tpt" },
+    ],
+    user: [
+        { rootKey: "usr", module: "administrator", key: "admin" },
+        { rootKey: "usr", module: "customer", key: "cust" },
+        { rootKey: "usr", module: "driver", key: "dvr" },
+        { rootKey: "usr", module: "supplier", key: "sup" },
+        { rootKey: "usr", module: "worker", key: "wkr" },
+    ],
+    branch_user: [
+        { rootKey: "brusr", module: "customer", key: "cust" },
+    ],
+    branch: [
+        { rootKey: "br", module: "customer", key: "cust" },
+    ],
+};
+const getCreatePayload = (mainType, data) => {
+    return {
+        injection_fields: data.map((i) => ({
+            field_key: i.fieldKey,
+            field_module: i.fieldModule,
+            field_ref: i.fieldRef,
+            field_type: i.fieldType
+        }))
+    };
+};
+const getUpdatePayload = (mainType, data) => {
+    return {
+        injection_fields: data.map((i) => ({
+            field_key: i.fieldKey,
+            field_module: i.fieldModule,
+            field_ref: i.fieldRef,
+            ref_id: i.refId,
+            field_value: i.value
+        }))
+    };
+};
+function getInjectionFieldsPayload({ referId, injectionFields, values, }) {
+    return Object.entries(values).map(([key, value]) => {
+        const field = injectionFields[key];
+        return {
+            refId: referId,
+            fieldRef: field.fieldRef,
+            fieldKey: field.fieldKey,
+            fieldModule: field.fieldModule,
+            value: value,
+        };
+    });
+}
+const InjectionFieldService = (props) => {
+    const { scopeType = "document", ...rest } = props ?? {};
+    const { makeCall } = (0, lib_1.ApiService)(rest?.customToken ? { customToken: rest.customToken } : {});
+    const endpoint1 = "injection_field";
+    const endpoint2 = "injection_fields";
+    const list = async (props) => {
+        const url = (0, lib_2.buildApiListUrl)(`${endpoint2}/injection_field`, props);
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+        return response;
+    };
+    const get = async (props) => {
+        const { id } = props;
+        const url = (0, lib_2.buildApiGetUrl)(`${endpoint1}/definition/${id}`, props);
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+        return response;
+    };
+    const create = async (props) => {
+        let url = `${endpoint1}`;
+        const { data, scopeType: overrideScopeType } = props;
+        let _scopeType = overrideScopeType || scopeType;
+        let payload = getCreatePayload(_scopeType, data);
+        let postData = {
+            scope: {
+                target: "injection_field",
+                action: "",
+            },
+            payload
+        };
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+        return response;
+    };
+    const remove = async ({ ids }) => {
+        let url = `${endpoint2}/delete`;
+        const postData = {
+            scope: {
+                target: "injection_field",
+            },
+            payload: {
+                ids
+            }
+        };
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+        return response;
+    };
+    // update field values - create if not exists
+    const updateInjectionFieldValues = async (props) => {
+        let url = `${endpoint1}`;
+        const { data, scopeType: overrideScopeType } = props;
+        let _scopeType = overrideScopeType || scopeType;
+        let payload = getUpdatePayload(_scopeType, data);
+        let postData = {
+            scope: {
+                target: overrideScopeType || scopeType,
+                action: "",
+            },
+            payload
+        };
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+        return response;
+    };
+    // get all scopes
+    const getInjectionFieldScopeTypes = () => {
+        return exports.injectionFieldScopeTypes;
+    };
+    // get all modules by scope type
+    const getInjectionFieldModulesByScopeType = (scopeType) => {
+        return exports.injectionFieldMap[scopeType];
+    };
+    return {
+        list,
+        get,
+        create,
+        remove,
+        updateInjectionFieldValues,
+        getInjectionFieldScopeTypes,
+        getInjectionFieldModulesByScopeType
+    };
+};
+exports.InjectionFieldService = InjectionFieldService;
+// const { create, getAllInjectionFieldScopeTypes, getAllInjectionFieldModulesByScopeType } = InjectionFieldService({ scopeType: "document" })
+// let payload: CreateInjectionFieldProps = {
+//     data: [{
+//         fieldKey: "",
+//         fieldModule: "",
+//         fieldRef: injectionFieldScopeTypes.branch.id as InjectionFieldScopeType,
+//     }]
+// }
+// const a = getAllInjectionFieldScopeTypes()
+// const b = getAllInjectionFieldModulesByScopeType("branch")

package/dist/services/inventory/InventoryService.d.ts

@@ -0,0 +1,27 @@
+import { ApiServiceType } from '@/lib';
+import { BuildApiListParamsProps } from '@/lib';
+export declare const inventoryTypes: {
+    readonly inventory: "inventory";
+    readonly inventoryRelocateThreshold: "relocate_threshold";
+    readonly inventoryReorderThreshold: "reorder_threshold";
+};
+export declare const inventoryTargetTypes: {
+    readonly inventory: "inventory";
+};
+export type InventoryType = typeof inventoryTypes[keyof typeof inventoryTypes];
+export type InventoryTargetType = typeof inventoryTargetTypes[keyof typeof inventoryTargetTypes];
+export type InventoryTargetKey = keyof typeof inventoryTargetTypes;
+export type InventoryServiceProps = ApiServiceType & {
+    inventoryTargetType?: InventoryTargetType;
+    inventoryType?: InventoryType;
+};
+export type ListInventoryProps = BuildApiListParamsProps & {
+    inventoryType?: InventoryType;
+};
+export declare const UserService: (props?: InventoryServiceProps) => {
+    list: (props: ListInventoryProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+};