storemw-core-api 1.0.0

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

@@ -0,0 +1,61 @@
+import { DefaultServiceProps } from "../../utils";
+type RepositoryInjectionFieldMap = {
+    package: {
+        repository: {
+            repositoryId: any;
+        };
+        repository_item: {
+            repositoryId: any;
+        };
+    };
+    container: {
+        repository: {
+            repositoryId: any;
+        };
+        repository_item: {
+            repositoryId: any;
+        };
+    };
+};
+type RepositoryInjectionFieldModule = keyof RepositoryInjectionFieldMap;
+export declare const repositoryModulePrefixMap: Record<RepositoryInjectionFieldModule, string>;
+export declare const repositoryRefPrefixMap: Record<"repository" | "repository_item", string>;
+export type RepositoryInjectionFieldModuleRef = {
+    [M in RepositoryInjectionFieldModule]: {
+        [R in keyof RepositoryInjectionFieldMap[M]]: {
+            module: M;
+            ref: R;
+        } & RepositoryInjectionFieldMap[M][R];
+    }[keyof RepositoryInjectionFieldMap[M]];
+}[RepositoryInjectionFieldModule];
+export type RepositoryInjectionFieldServiceProps = DefaultServiceProps & {};
+export type RepositoryInjectionFieldRemoveProps = {
+    ids: number[];
+};
+export type RepositoryInjectionFieldReplaceProps = {
+    data: RepositoryInjectionFieldModuleRef & {
+        fields: any;
+    };
+};
+export declare const RepositoryInjectionFieldService: (props: RepositoryInjectionFieldServiceProps) => {
+    replaceRepositoryInjectionField: ({ data }: RepositoryInjectionFieldReplaceProps) => Promise<{
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        field_module: string | null;
+        field_ref: string | null;
+        repository_injection_field_id: bigint;
+        repository_id: bigint;
+        repository_item_id: bigint | null;
+        cont_repo_tes: import("../../generated/prisma/runtime/library").Decimal | null;
+        repo_cont_repo_t3es: import("../../generated/prisma/runtime/library").Decimal | null;
+        repo_pk_pk_cont: import("../../generated/prisma/runtime/library").Decimal | null;
+        repo_itme_pk_pk_cont_item: import("../../generated/prisma/runtime/library").Decimal | null;
+        repo_itme_cont_pk_cont_item: import("../../generated/prisma/runtime/library").Decimal | null;
+    }>;
+};
+export {};

package/dist/services/injection_field/RepositoryInjectionFieldService.js

@@ -0,0 +1,66 @@
+"use strict";
+// import { logError, throwError } from "../../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryInjectionFieldService = exports.repositoryRefPrefixMap = exports.repositoryModulePrefixMap = void 0;
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+// type RepositoryInjectionFieldRef<M extends RepositoryInjectionFieldModule> = keyof RepositoryInjectionFieldMap[M];
+exports.repositoryModulePrefixMap = {
+    package: "pk",
+    container: "cont",
+};
+exports.repositoryRefPrefixMap = {
+    repository: "repo",
+    repository_item: "repo_item",
+};
+const getReplacePayload = (data) => {
+    let { module, ref, repositoryId } = data;
+    let payload = {};
+    payload = {
+        ...payload,
+        ...{
+            [`${models_1.ModelRepositoryInjectionFieldFields.field_module}`]: module,
+            [`${models_1.ModelRepositoryInjectionFieldFields.field_ref}`]: ref,
+        }
+    };
+    if ("repositoryId" in data) {
+        payload = { ...payload, ...(data?.repositoryId ? { [`${models_1.ModelRepositoryInjectionFieldFields.repository_id}`]: repositoryId } : {}) };
+    }
+    const rest = data.fields;
+    // apply dynamic prefix: refPrefix_modulePrefix_fieldKey
+    const refPrefix = exports.repositoryRefPrefixMap[ref] ?? ref;
+    const modulePrefix = exports.repositoryModulePrefixMap[module] ?? module;
+    for (const [key, value] of Object.entries(rest)) {
+        payload[`${refPrefix}_${modulePrefix}_${key}`] = value;
+    }
+    return payload;
+};
+const RepositoryInjectionFieldService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const repositoryInjectionFieldModel = (0, models_1.RepositoryInjectionFieldModel)({ prisma, accountId, actionUserId });
+    const replaceRepositoryInjectionField = async ({ data }) => {
+        const _data = getReplacePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        const where = {
+            [models_1.ModelRepositoryInjectionFieldFields.field_module]: data.module,
+            [models_1.ModelRepositoryInjectionFieldFields.field_ref]: data.ref,
+            ...(data?.repositoryId ? { [models_1.ModelRepositoryInjectionFieldFields.repository_id]: data.repositoryId } : {}),
+        };
+        // Narrow: only include branchId if data.ref === "branch"
+        // if (data.ref === "branch") {
+        //     where[ModelRepositoryInjectionFieldFields.branch_id] = (data as Extract<RepositoryInjectionFieldModuleRef, { ref: "branch" }>).branchId;
+        // }
+        let modelFields = await repositoryInjectionFieldModel.getFields();
+        let finalData = (0, utils_1.convertPayloadByTableSchema)(_data, modelFields);
+        console.log('modelFields', modelFields);
+        console.log('finalData', finalData);
+        const response = await repositoryInjectionFieldModel.update({ data: finalData, where });
+        return response;
+    };
+    return {
+        replaceRepositoryInjectionField
+    };
+};
+exports.RepositoryInjectionFieldService = RepositoryInjectionFieldService;

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

@@ -0,0 +1,98 @@
+import { DefaultServiceProps } from "../../utils";
+type UserInjectionFieldMap = {
+    customer: {
+        user: {
+            userId: any;
+        };
+        branch: {
+            userId: any;
+            branchId: any;
+        };
+    };
+    retailer: {
+        user: {
+            userId: any;
+        };
+        branch: {
+            userId: any;
+            branchId: any;
+        };
+    };
+    administrator: {
+        user: {
+            userId: any;
+        };
+    };
+    supplier: {
+        user: {
+            userId: any;
+        };
+    };
+    driver: {
+        user: {
+            userId: any;
+        };
+    };
+    worker: {
+        user: {
+            userId: any;
+        };
+    };
+    member: {
+        user: {
+            userId: any;
+        };
+    };
+};
+type UserInjectionFieldModule = keyof UserInjectionFieldMap;
+export declare const userModulePrefixMap: Record<UserInjectionFieldModule, string>;
+export declare const userRefPrefixMap: Record<"user" | "branch", string>;
+export type UserInjectionFieldModuleRef = {
+    [M in UserInjectionFieldModule]: {
+        [R in keyof UserInjectionFieldMap[M]]: {
+            module: M;
+            ref: R;
+        } & UserInjectionFieldMap[M][R];
+    }[keyof UserInjectionFieldMap[M]];
+}[UserInjectionFieldModule];
+export type UserInjectionFieldServiceProps = DefaultServiceProps & {};
+export type UserInjectionFieldRemoveProps = {
+    ids: number[];
+};
+export type UserInjectionFieldReplaceProps = {
+    data: UserInjectionFieldModuleRef & {
+        fields: any;
+    };
+};
+export declare const UserInjectionFieldService: (props: UserInjectionFieldServiceProps) => {
+    replaceUserInjectionField: ({ data }: UserInjectionFieldReplaceProps) => Promise<{
+        user_id: bigint;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        member_id: bigint | null;
+        branch_id: bigint | null;
+        field_module: string | null;
+        field_ref: string | null;
+        user_injection_field_id: bigint;
+        usr_cust_cust_qty: bigint | null;
+        br_cust_branch_qty: bigint | null;
+        usr_cust_customer_branch_marking: string | null;
+        br_cust_customer_branch_marking: string | null;
+        usr_cust_customer_marking: string | null;
+        br_cust_postcode: string | null;
+        usr_cust_source_agent_remid: string | null;
+        usr_cust_source_client_remid: string | null;
+        br_cust_source_marking_remid: string | null;
+        usr_cust_source_profile_type: string | null;
+        br_cust_branch3_qty: import("../../generated/prisma/runtime/library").Decimal | null;
+        usr_mb_member_test: bigint | null;
+        removed_usr_cust_222333223: Date | null;
+        removed_br_ret_4sdfsdfd7s: string | null;
+    }>;
+};
+export {};

package/dist/services/injection_field/UserInjectionFieldService.js

@@ -0,0 +1,79 @@
+"use strict";
+// import { logError, throwError } from "../../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserInjectionFieldService = exports.userRefPrefixMap = exports.userModulePrefixMap = void 0;
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+// type UserInjectionFieldRef<M extends UserInjectionFieldModule> = keyof UserInjectionFieldMap[M];
+exports.userModulePrefixMap = {
+    customer: "cust",
+    retailer: "ret",
+    administrator: "admin",
+    supplier: "sup",
+    driver: "drv",
+    worker: "wrk",
+    member: "mb",
+};
+exports.userRefPrefixMap = {
+    user: "usr",
+    branch: "br",
+};
+const getReplacePayload = (data) => {
+    let { module, ref, userId } = data;
+    let payload = {};
+    payload = {
+        ...payload,
+        ...{
+            [`${models_1.ModelUserInjectionFieldFields.field_module}`]: module,
+            [`${models_1.ModelUserInjectionFieldFields.field_ref}`]: ref,
+        }
+    };
+    if ("userId" in data) {
+        payload = { ...payload, ...(data?.userId ? { [`${models_1.ModelUserInjectionFieldFields.user_id}`]: userId } : {}) };
+    }
+    if ("branchId" in data) {
+        const branchId = data.branchId;
+        payload = { ...payload, ...(data?.branchId ? { [`${models_1.ModelUserInjectionFieldFields.branch_id}`]: branchId } : {}) };
+    }
+    if ("memberId" in data) {
+        const memberId = data.memberId;
+        payload = { ...payload, ...(data?.memberId ? { [`${models_1.ModelUserInjectionFieldFields.member_id}`]: memberId } : {}) };
+    }
+    const rest = data.fields;
+    // apply dynamic prefix: refPrefix_modulePrefix_fieldKey
+    const refPrefix = exports.userRefPrefixMap[ref] ?? ref;
+    const modulePrefix = exports.userModulePrefixMap[module] ?? module;
+    for (const [key, value] of Object.entries(rest)) {
+        payload[`${refPrefix}_${modulePrefix}_${key}`] = value;
+    }
+    return payload;
+};
+const UserInjectionFieldService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const userInjectionFieldModel = (0, models_1.UserInjectionFieldModel)({ prisma, accountId, actionUserId });
+    const replaceUserInjectionField = async ({ data }) => {
+        const _data = getReplacePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        const where = {
+            [models_1.ModelUserInjectionFieldFields.field_module]: data.module,
+            [models_1.ModelUserInjectionFieldFields.field_ref]: data.ref,
+            ...(data?.userId ? { [models_1.ModelUserInjectionFieldFields.user_id]: data.userId } : {}),
+        };
+        // Narrow: only include branchId if data.ref === "branch"
+        if (data.ref === "branch") {
+            where[models_1.ModelUserInjectionFieldFields.branch_id] = data.branchId;
+        }
+        let modelFields = await userInjectionFieldModel.getFields();
+        let finalData = (0, utils_1.convertPayloadByTableSchema)(_data, modelFields);
+        console.log('modelFields', modelFields);
+        console.log('finalData', finalData);
+        const response = await userInjectionFieldModel.update({ data: finalData, where });
+        return response;
+    };
+    return {
+        replaceUserInjectionField
+    };
+};
+exports.UserInjectionFieldService = UserInjectionFieldService;

package/dist/services/item/ItemBrandService.d.ts

@@ -0,0 +1,84 @@
+import { QueryList } from "../../schema/common";
+import { DefaultServiceProps } from "../../utils";
+export type ItemType = "brand";
+export declare const brandDataTypes: {
+    brandInjectionFields: string;
+};
+export type ItemBrandDataType = keyof typeof brandDataTypes;
+export type ItemBrandServiceProps = DefaultServiceProps & {};
+export type ItemBrandGetProps = {
+    id: number;
+    datatypes: ItemBrandDataType[];
+};
+export type ItemBrandListProps = QueryList & {
+    datatypes: ItemBrandDataType[];
+};
+export type ItemBrandRemoveProps = {
+    brandIds: BigInt[];
+};
+export type ItemBrandCreateProps = {
+    data: {
+        brand: {
+            name: string;
+            description: string;
+            status: boolean;
+        };
+    };
+};
+export type ItemBrandUpdateProps = {
+    brandId: number;
+    data: {
+        brand: {
+            name: string;
+            description: string;
+            status: boolean;
+        };
+    };
+};
+export declare const ItemBrandService: (props: ItemBrandServiceProps) => {
+    createBrand: ({ data }: ItemBrandCreateProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        brand_id: bigint;
+        description: string | null;
+    }>;
+    updateBrand: ({ brandId, data }: ItemBrandUpdateProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        brand_id: bigint;
+        description: string | null;
+    }>;
+    getBrand: ({ id, datatypes }: ItemBrandGetProps) => Promise<any>;
+    listBrands: ({ limit, offset, filters, sortfield, sortorder, datatypes }: ItemBrandListProps) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    removeBrands: ({ brandIds }: ItemBrandRemoveProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        brand_id: bigint;
+        description: string | null;
+    }[]>;
+    getDataTypes: () => string[];
+};

package/dist/services/item/ItemBrandService.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemBrandService = exports.brandDataTypes = void 0;
+const utils_1 = require("../../utils");
+const models_1 = require("../../models");
+const services_1 = require("../../services");
+const utils_2 = require("../../utils");
+exports.brandDataTypes = {
+    brandInjectionFields: "brand_injection_fields"
+};
+const getCreatePayload = (data) => {
+    if ("brand" in data) {
+        return {
+            [`${models_1.ModelBrandFields.name}`]: data.brand.description,
+            [`${models_1.ModelBrandFields.description}`]: data.brand.description,
+            [`${models_1.ModelBrandFields.status}`]: data.brand.status ? 1 : 0
+        };
+    }
+    return false;
+};
+const getUpdatePayload = (data) => {
+    if ("brand" in data) {
+        return {
+            // [`${ModelBrandFields.brand_id}`]: data.brand.parentbrandId,
+            [`${models_1.ModelBrandFields.name}`]: data.brand.description,
+            [`${models_1.ModelBrandFields.description}`]: data.brand.description,
+            [`${models_1.ModelBrandFields.status}`]: data.brand.status ? 1 : 0
+        };
+    }
+    return false;
+};
+let mainSqlSelect = {
+    [`brd.${models_1.ModelBrandFields.brand_id}`]: "brand_id",
+    [`brd.${models_1.ModelBrandFields.description}`]: "description",
+    [`brd.${models_1.ModelBrandFields.name}`]: "name",
+    [`brd.${models_1.ModelBrandFields.status}`]: "status",
+};
+let defaultSqlSelect = {
+    [`brd.${models_1.ModelBrandFields.createdatetime}`]: "createdatetime",
+    [`creator.${models_1.ModelUserFields.login_username}`]: "createusername",
+    [`brd.${models_1.ModelBrandFields.updatedatetime}`]: "updatedatetime",
+    [`updater.${models_1.ModelUserFields.login_username}`]: "updateusername",
+    [`brd.${models_1.ModelBrandFields.isdelete}`]: "isdelete",
+    [`brd.${models_1.ModelBrandFields.istrash}`]: "istrash",
+    [`brd.${models_1.ModelBrandFields.accountid}`]: "accountid",
+};
+const ItemBrandService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const injectionFieldService = (0, services_1.InjectionFieldService)({ prisma, accountId, actionUserId, injectionFieldType: "item" });
+    const brandModel = (0, models_1.BrandModel)({ prisma, accountId, actionUserId });
+    const createBrand = async ({ data }) => {
+        const _data = getCreatePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create brand payload: ${JSON.stringify(_data)}`);
+        }
+        let response = await brandModel.create({ data: _data });
+        return response;
+    };
+    const updateBrand = async ({ brandId, data }) => {
+        const _data = getUpdatePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid update brand payload: ${JSON.stringify(_data)}`);
+        }
+        let response = await brandModel.update({ where: { [`${models_1.ModelBrandFields.brand_id}`]: brandId }, data: _data });
+        return response;
+    };
+    const getBrand = async ({ id, datatypes = [] }) => {
+        let { data } = await listBrands({
+            limit: 1,
+            offset: 0,
+            filters: [{ field: `${models_1.ModelBrandFields.brand_id}`, operator: "=", value: id }],
+            sortfield: `${models_1.ModelBrandFields.brand_id}`,
+            sortorder: "ASC",
+            datatypes
+        });
+        return data[0] ?? null;
+    };
+    const listBrands = async ({ limit, offset, filters, sortfield, sortorder, datatypes = [] }) => {
+        let data = [];
+        let sqlSelect = [
+            `COUNT(brd.*) OVER() as filtered_count`,
+            (0, utils_2.buildSqlSelect)(``, mainSqlSelect),
+            (0, utils_2.buildSqlSelect)(``, defaultSqlSelect),
+        ];
+        let sqlRelation = [
+            (0, utils_2.buildSqlRelation)("left", "brd", "users", "creator", ["brd.createuserid = creator.user_id", "creator.isdelete = false", "creator.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "brd", "users", "updater", ["brd.updateuserid = updater.user_id", "updater.isdelete = false", "updater.istrash = false"])
+        ];
+        let sqlGroupBy = [
+            ...Object.keys(mainSqlSelect),
+            ...Object.keys(defaultSqlSelect)
+        ];
+        let filterColumns = {
+            ...mainSqlSelect,
+            ...defaultSqlSelect
+        };
+        if (datatypes.includes(exports.brandDataTypes.brandInjectionFields)) {
+            let activeInjectionFields = await injectionFieldService.listActiveInjectionFields("item", "brand");
+            const brandInjectionFieldSqlSelect = activeInjectionFields.reduce((acc, col) => {
+                acc[`uip.${col}`] = `${col}`;
+                return acc;
+            }, {});
+            filterColumns = { ...filterColumns, ...brandInjectionFieldSqlSelect };
+            sqlSelect = [...sqlSelect, ...(activeInjectionFields.length > 0 ? [(0, utils_2.buildSqlSelect)(``, brandInjectionFieldSqlSelect)] : [])];
+            sqlRelation = [...sqlRelation, (0, utils_2.buildSqlRelation)("left", "brd", "item_injection_fields", "uip", ["brd.brand_id = uip.brand_id", "uip.field_ref = 'item'", "uip.field_module = 'brand'", "uip.isdelete = false", "uip.istrash = false"])];
+            sqlGroupBy = [...sqlGroupBy, ...Object.keys(brandInjectionFieldSqlSelect)];
+        }
+        let sqlWhere = [
+            `brd.isdelete = false`,
+            `brd.istrash = false`,
+            ...(filters.length ? [(0, utils_2.buildSqlWhere)(filters, filterColumns)] : []),
+        ];
+        let sqlOrderby = (0, utils_2.buildSqlOrderBy)(sortfield, sortorder);
+        let sqlLimitOffset = (0, utils_2.buildSqlLimitOffset)(limit, offset);
+        const sqlRaw = (0, utils_2.buildSqlRawSelect)({
+            tableName: "brands",
+            mainAlias: "brd",
+            accountId,
+            sqlSelect,
+            sqlRelation,
+            sqlWhere,
+            sqlGroupBy,
+            sqlOrderby,
+            sqlLimitOffset
+        });
+        data = await brandModel.raw(sqlRaw);
+        const response = {
+            data: data.map(({ filtered_count, ...rest }) => rest),
+            total: data.length ? Number(data[0].filtered_count) : 0
+        };
+        return response;
+    };
+    const removeBrands = async ({ brandIds }) => {
+        if (!brandIds.length)
+            (0, utils_1.throwError)('brandIds is required');
+        const response = await brandModel.remove({ where: { [`${models_1.ModelBrandFields.brand_id}`]: { in: brandIds } } });
+        return response;
+    };
+    const getDataTypes = () => {
+        return Object.values(exports.brandDataTypes);
+    };
+    return {
+        createBrand,
+        updateBrand,
+        getBrand,
+        listBrands,
+        removeBrands,
+        getDataTypes
+    };
+};
+exports.ItemBrandService = ItemBrandService;

package/dist/services/item/ItemCategoryService.d.ts

@@ -0,0 +1,89 @@
+import { QueryList } from "../../schema/common";
+import { DefaultServiceProps } from "../../utils";
+export type ItemType = "category";
+export declare const categoryDataTypes: {
+    categoryInjectionFields: string;
+};
+export type ItemCategoryDataType = keyof typeof categoryDataTypes;
+export type ItemCategoryServiceProps = DefaultServiceProps & {};
+export type ItemCategoryGetProps = {
+    id: number;
+    datatypes: ItemCategoryDataType[];
+};
+export type ItemCategoryListProps = QueryList & {
+    datatypes: ItemCategoryDataType[];
+};
+export type ItemCategoryRemoveProps = {
+    categoryIds: BigInt[];
+};
+export type ItemCategoryCreateProps = {
+    data: {
+        category: {
+            parentCategoryId: number;
+            name: string;
+            description: string;
+            status: boolean;
+        };
+    };
+};
+export type ItemCategoryUpdateProps = {
+    categoryId: number;
+    data: {
+        category: {
+            parentCategoryId: number;
+            name: string;
+            description: string;
+            status: boolean;
+        };
+    };
+};
+export declare const ItemCategoryService: (props: ItemCategoryServiceProps) => {
+    createCategory: ({ data }: ItemCategoryCreateProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        category_id: bigint;
+        description: string | null;
+        parent_category_id: bigint;
+    }>;
+    updateCategory: ({ categoryId, data }: ItemCategoryUpdateProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        category_id: bigint;
+        description: string | null;
+        parent_category_id: bigint;
+    }>;
+    getCategory: ({ id, datatypes }: ItemCategoryGetProps) => Promise<any>;
+    listCategories: ({ limit, offset, filters, sortfield, sortorder, datatypes }: ItemCategoryListProps) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    removeCategories: ({ categoryIds }: ItemCategoryRemoveProps) => Promise<{
+        status: number | null;
+        name: string | null;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        category_id: bigint;
+        description: string | null;
+        parent_category_id: bigint;
+    }[]>;
+    getDataTypes: () => string[];
+};