@autofleet/sadot 1.1.5 → 1.1.6-beta

package/dist/events/index.js

@@ -1,2 +1,54 @@
-import e from"../utils/logger/index.js";import{getUser as t}from"@autofleet/zehut";import n from"@autofleet/events";const r=new n({logger:e,getUserId:e=>e?.user_id??t()?.id??null}),i=[`value`,`defaultValue`,`blockEditingFromUI`],a=(e,t)=>{let n=new Set(Object.keys(e));return t.every(e=>!n.has(e))?e:{...e,...Object.fromEntries(t.map(t=>[t,typeof e[t]==`boolean`?e[t].toString():e[t]]))}},o={CustomFieldDefinition:{tableName:`dim_custom_field_definition`,eventVersion:`1`},CustomFieldValue:{tableName:`dim_custom_field_value`,eventVersion:`1`},CustomFieldEntries:{tableName:`dim_custom_field_entries`,eventVersion:`1`}},s=t=>{let n=o[t.constructor.name];if(!n)return;let s=t.get();try{s=a(t.get(),i)}catch(t){e.error(`Failed to convert booleans in dim event payload`,t)}r.sendObject(n.tableName,n.eventVersion,s).catch(()=>null)};export{s as sendDimEvent};
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDimEvent = void 0;
+const events_1 = __importDefault(require("@autofleet/events"));
+const zehut_1 = require("@autofleet/zehut");
+const logger_1 = __importDefault(require("../utils/logger"));
+const events = new events_1.default({
+    logger: logger_1.default,
+    getUserId: (payload) => payload?.user_id ?? (0, zehut_1.getUser)()?.id ?? null,
+});
+const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
+const stringifyBooleans = (savedObject, keysToConvert) => {
+    const savedObjectKeySet = new Set(Object.keys(savedObject));
+    if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
+        return savedObject;
+    }
+    return {
+        ...savedObject,
+        ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
+    };
+};
+const modelTableMapping = {
+    CustomFieldDefinition: {
+        tableName: 'dim_custom_field_definition',
+        eventVersion: '1',
+    },
+    CustomFieldValue: {
+        tableName: 'dim_custom_field_value',
+        eventVersion: '1',
+    },
+    CustomFieldEntries: {
+        tableName: 'dim_custom_field_entries',
+        eventVersion: '1',
+    },
+};
+const sendDimEvent = (instance) => {
+    const mapping = modelTableMapping[instance.constructor.name];
+    if (!mapping) {
+        return;
+    }
+    let objectToSend = instance.get();
+    try {
+        objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to convert booleans in dim event payload', err);
+    }
+    events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend).catch(() => { });
+};
+exports.sendDimEvent = sendDimEvent;
+exports.default = events;

package/dist/hooks/create.d.ts

@@ -0,0 +1,10 @@
+import type { CustomFieldOptions, ModelOptions } from '../types';
+/**
+ * A hook to create the custom fields when updating a model (more then one instance).
+ */
+export declare const beforeBulkCreate: (options: any) => void;
+/**
+ * A hook to create the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/create.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeCreate = exports.beforeBulkCreate = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
+const DefinitionRepo = __importStar(require("../repository/definition"));
+const errors_1 = require("../errors");
+const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
+/**
+ * A hook to create the custom fields when updating a model (more then one instance).
+ */
+const beforeBulkCreate = (options) => {
+    // This will activate the beforeCreate hook on each updating instance.
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkCreate = beforeBulkCreate;
+/**
+ * A hook to create the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+    logger_1.default.debug('sadot - before create hook');
+    const { fields } = options;
+    const { include, useEntityIdFromInclude } = modelOptions;
+    const modelType = instance.constructor.name;
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    const where = {
+        modelType,
+        disabled: false,
+        ...(!useEntityIdFromInclude && { entityId: identifiers }),
+    };
+    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: false, transaction: options.transaction, include: include?.(identifiers) });
+    const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
+    const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+    if (fieldsWithDefaultValue.length) {
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields || (instance.customFields = {});
+        fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
+            // eslint-disable-next-line no-param-reassign
+            instance.customFields[name] = defaultValue;
+        });
+    }
+    const { customFields } = instance;
+    const fieldsNames = Object.keys(customFields ?? {});
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length) {
+        throw new errors_1.MissingRequiredCustomFieldError(missingFields);
+    }
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+        // After checking for required fields and fields with default values, and we have no custom fields.
+        return;
+    }
+    await (0, updateInstanceValues_1.default)({
+        modelId: instance.id,
+        modelType,
+        identifiers,
+        customFields,
+        options: {
+            useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+            transaction: options.transaction,
+            modelOptions,
+        },
+    });
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+};
+exports.beforeCreate = beforeCreate;

package/dist/hooks/enrich.d.ts

@@ -0,0 +1,25 @@
+import type CustomFieldValue from '../models/CustomFieldValue';
+import type { CustomFieldOptions, ModelOptions, TransactionOptions } from '../types';
+type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
+type CustomFieldEntries = Record<string, any>;
+interface GetValuesGroupByInstanceResponse {
+    [modelId: string]: CustomFieldValue[];
+}
+interface GetCustomFieldEntriesByInstanceIdResponse {
+    [modelId: string]: CustomFieldEntries;
+}
+export declare const getCustomFieldEntriesByInstanceId: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: TransactionOptions;
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetCustomFieldEntriesByInstanceIdResponse>;
+export declare const getValuesGroupByInstance: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: TransactionOptions;
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetValuesGroupByInstanceResponse>;
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instancesOrInstance: any | any[], options: TransactionOptions) => Promise<void>;
+export default enrichResults;

package/dist/hooks/enrich.js

@@ -1,2 +1,198 @@
-import{findByEntityIds as e}from"../repository/definition.js";import{findValuesByModelIds as t}from"../repository/value.js";import{findEntriesByModelIds as n}from"../repository/entries.js";import r from"../utils/scopeAttributes.js";const i=[`id`,`name`,`entityId`,`fieldType`,`displayName`,`validation`,`entityType`,`modelType`,`required`,`disabled`,`defaultValue`],a=async({instancesIds:e,options:t,sadotOptions:r})=>{if(!r.useCustomFieldsEntries)return{};let i=await n(e,t??{}),a=Object.fromEntries(i.map(e=>{let{modelId:t,customFields:n}=e?.dataValues??{};if(t)return[t,n]}).filter(e=>e!==void 0));return e.forEach(e=>{a[e]??={}}),a},o=async({instancesIds:e,options:n,sadotOptions:r})=>r.useCustomFieldsEntries?{}:(await t(e,n??{})).reduce((e,t)=>{let{modelId:n}=t;return e[n]??=[],e[n].push(t),e},{}),s=(e,t)=>e.reduce((e,n)=>({...e,...t[n.customFieldDefinitionId]&&{[t[n.customFieldDefinitionId].name]:n.value}}),{});var c=(t,n,c,l={},u={useCustomFieldsEntries:!1})=>async(d,f)=>{if(f.originalAttributes?.length>0&&!f.originalAttributes?.includes?.(`customFields`))return;let p=Array.isArray(d)?d:[d];p=p.filter(Boolean);let m=r(p,n),h=[...new Set(m)].filter(Boolean),g=h.reduce((e,t)=>({...e,[t]:[]}),{}),_,v;f.transaction&&(f.transaction.definitionCache??=new Map,v=`${t}:${h.slice().sort().join(`,`)}`,_=f.transaction.definitionCache.get(v)),_||(_=e(t,h,{transaction:f.transaction,modelOptions:l,attributes:i}),f.transaction?.definitionCache?.set(v,_));let y=await _;if(y.length===0){p.forEach(e=>{e.customFields={}});return}l?.include&&l.useEntityIdFromInclude&&l.include(m).forEach(({model:e})=>{y.forEach(t=>{let n=t[`${e.name}.entityId`];g[n]=[]})});let b=y.reduce((e,t)=>({...e,[t.id]:t}),{});y.forEach(e=>{g[e.entityId].push(e)});let x=p.map(e=>e.id),[S,C]=await Promise.all([o({instancesIds:x,options:f,sadotOptions:u}),a({instancesIds:x,options:f,sadotOptions:u})]);p.forEach(e=>{let{id:t}=e,r=S[t],i=r?s(r,b):{},a=u.useCustomFieldsEntries?C[t]:i;n.forEach(t=>{let n=g[e[t]];n&&n.length>0&&n.forEach(e=>{a[e.name]===void 0&&(a[e.name]=null)})}),e.customFields=a,f.attributesToRemove?.forEach?.(t=>{delete e.dataValues?.[t],delete e?.[t]}),c===`afterFind`&&e?.changed?.(`customFields`,!1)})};export{c as default};
-//# sourceMappingURL=enrich.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValuesGroupByInstance = exports.getCustomFieldEntriesByInstanceId = void 0;
+/* eslint-disable no-param-reassign */
+const ValueRepo = __importStar(require("../repository/value"));
+const DefinitionRepo = __importStar(require("../repository/definition"));
+const EntriesRepo = __importStar(require("../repository/entries"));
+const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+// Include all required fields for proper functioning
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = [
+    'id',
+    'name',
+    'entityId',
+    'fieldType',
+    'displayName',
+    'validation',
+    'entityType',
+    'modelType',
+    'required',
+    'disabled',
+    'defaultValue',
+];
+const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions, }) => {
+    if (!sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldEntries = await EntriesRepo.findEntriesByModelIds(instancesIds, options ?? {});
+    const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+        const { modelId, customFields } = instanceEntries?.dataValues ?? {};
+        if (!modelId) {
+            return undefined;
+        }
+        return [modelId, customFields];
+    }).filter(Boolean));
+    instancesIds.forEach((instanceId) => {
+        customFieldEntriesByInstanceId[instanceId] ?? (customFieldEntriesByInstanceId[instanceId] = {});
+    });
+    return customFieldEntriesByInstanceId;
+};
+exports.getCustomFieldEntriesByInstanceId = getCustomFieldEntriesByInstanceId;
+const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions, }) => {
+    if (sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, options ?? {});
+    // Group fields by modelId
+    return customFieldValues.reduce((acc, v) => {
+        const { modelId } = v;
+        acc[modelId] ?? (acc[modelId] = []);
+        acc[modelId].push(v);
+        return acc;
+    }, {});
+};
+exports.getValuesGroupByInstance = getValuesGroupByInstance;
+/**
+ * Serialize custom fields value into the format of {[name] -> [fieldData]}
+ */
+const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) => {
+    const customFields = customFieldValues.reduce((acc, cfv) => ({
+        ...acc,
+        ...(customFieldDefinitionsHash[cfv.customFieldDefinitionId]
+            && { [customFieldDefinitionsHash[cfv.customFieldDefinitionId].name]: cfv.value }),
+    }), {});
+    return customFields;
+};
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instancesOrInstance, options) => {
+    var _a;
+    if (options.originalAttributes?.length > 0
+        && !options.originalAttributes?.includes?.('customFields')) {
+        return;
+    }
+    const primaryKey = 'id';
+    let instances = Array.isArray(instancesOrInstance)
+        ? instancesOrInstance
+        : [instancesOrInstance];
+    instances = instances.filter(Boolean);
+    const identifiers = (0, scopeAttributes_1.default)(instances, scopeAttributes);
+    const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+    const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
+        ...map,
+        [identifier]: [],
+    }), {});
+    // Cache for definitions by model type and transaction to avoid redundant DB queries
+    let customFieldDefinitionsPromise;
+    let cacheKey;
+    if (options.transaction) {
+        // Initialize definition cache Map if not already present directly on the transaction object
+        (_a = options.transaction).definitionCache || (_a.definitionCache = new Map());
+        cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(',')}`;
+        customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+    }
+    if (!customFieldDefinitionsPromise) {
+        // Fetch from database (either first time in this transaction or no transaction)
+        customFieldDefinitionsPromise = DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions, attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL });
+        options.transaction?.definitionCache?.set(cacheKey, customFieldDefinitionsPromise);
+    }
+    const customFieldDefinitions = await customFieldDefinitionsPromise;
+    if (customFieldDefinitions.length === 0) {
+        // if no custom fields, we can return
+        instances.forEach((instance) => {
+            instance.customFields = {};
+        });
+        return;
+    }
+    if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
+        // if we pass useEntityIdFromInclude,
+        //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
+        modelOptions.include(identifiers).forEach(({ model }) => {
+            customFieldDefinitions.forEach((cfd) => {
+                const entityId = cfd[`${model.name}.entityId`];
+                identifierCustomFieldDefinitionsMapping[entityId] = [];
+            });
+        });
+    }
+    const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
+        ...map,
+        [definition.id]: definition,
+    }), {});
+    customFieldDefinitions.forEach((cfd) => {
+        identifierCustomFieldDefinitionsMapping[cfd.entityId].push(cfd);
+    });
+    // Get the values per instates ids:
+    const instancesIds = instances.map((i) => i[primaryKey]);
+    // Group fields by modelId
+    const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([
+        (0, exports.getValuesGroupByInstance)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+        (0, exports.getCustomFieldEntriesByInstanceId)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+    ]);
+    // Attach custom fields to the instances
+    instances.forEach((instance) => {
+        const { id } = instance;
+        const instanceValues = valuesGroupByInstance[id];
+        const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+        const customFields = sadotOptions.useCustomFieldsEntries
+            ? customFieldEntriesByInstanceId[id]
+            : serializedCustomFieldsValues;
+        scopeAttributes.forEach((attribute) => {
+            const identifier = instance[attribute];
+            const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
+            if (entityCustomFieldDefinitions?.length > 0) {
+                entityCustomFieldDefinitions.forEach((customFieldDefinition) => {
+                    if (customFields[customFieldDefinition.name] === undefined) {
+                        customFields[customFieldDefinition.name] = null;
+                    }
+                });
+            }
+        });
+        instance.customFields = customFields;
+        options.attributesToRemove?.forEach?.((attribute) => {
+            delete instance.dataValues?.[attribute];
+            // if raw:
+            delete instance?.[attribute];
+        });
+        // sequelize will think customFields changed also in 'find', so we need to mark it as unchanged
+        if (hookType === 'afterFind') {
+            // changed() could be undefined, i.e in raw: true
+            instance?.changed?.('customFields', false);
+        }
+    });
+};
+exports.default = enrichResults;

package/dist/hooks/find.d.ts

@@ -0,0 +1 @@
+export declare const beforeFind: (scopeAttributes: string[]) => (options: any) => void;

package/dist/hooks/find.js

@@ -1,2 +1,29 @@
-import e from"../utils/logger/index.js";const t=(e,t)=>{let n=e.filter(e=>!t.includes(e));return t.includes?.(`id`)||n.push(`id`),n},n=n=>r=>{let{attributes:i}=r;if(i?.includes?.(`customFields`)){let a=t(n,i);e.debug(`sadot - before find hook`),a?.length>0&&(i.push(...a),r.attributesToRemove=a)}};export{n as beforeFind};
-//# sourceMappingURL=find.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeFind = void 0;
+/* eslint-disable no-param-reassign */
+const logger_1 = __importDefault(require("../utils/logger"));
+const doScopeAttributesMissing = (scopeAttributes, queryAttributes) => {
+    const attributes = scopeAttributes
+        .filter((attribute) => !queryAttributes.includes(attribute));
+    if (!queryAttributes.includes?.('id')) {
+        attributes.push('id');
+    }
+    return attributes;
+};
+// eslint-disable-next-line import/prefer-default-export
+const beforeFind = (scopeAttributes) => (options) => {
+    const { attributes: queryAttributes } = options;
+    if (queryAttributes?.includes?.('customFields')) {
+        const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
+        logger_1.default.debug('sadot - before find hook');
+        if (missingScopeAttributes?.length > 0) {
+            queryAttributes.push(...missingScopeAttributes);
+            options.attributesToRemove = missingScopeAttributes;
+        }
+    }
+};
+exports.beforeFind = beforeFind;

package/dist/hooks/hooks.d.ts

@@ -0,0 +1,17 @@
+import type { CustomFieldOptions, ModelOptions } from '../types';
+/**
+ * Hook to handle validation and custom fields during creation
+ */
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;
+/**
+ * Hook to handle validation and custom fields during update
+ */
+export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;
+/**
+ * Hook to enable individual hooks for bulk create operations
+ */
+export declare const beforeBulkCreate: (options: any) => void;
+/**
+ * Hook to enable individual hooks for bulk update operations
+ */
+export declare const beforeBulkUpdate: (options: any) => void;