firstly 0.0.16-next.2 → 0.1.0-next.4

package/esm/changeLog/server/index.js

@@ -1,42 +1,53 @@
-import { Module } from '../../server';
-import { ChangeLog } from '../index';
+import { Module } from 'remult/server';
+import { ChangeLog } from '../changeLogEntities';
 /**
- * ## Default way
- * The easiest is to switch from `@Entity` to `@FF_Entity` to the entities where you want to log changes.
+ * We suggest you to create your own `@APP_Entity` decorator and use it instead of `@Entity`.
+ * Like this you opt-in to the change log feature Entity by Entity.
  *
+ * @example
  * ```ts
- * \@FF_Entity<User>('users', {
+ * // APP_Entity.ts example
+ * import { Entity, isBackend, type EntityOptions } from 'remult'
  *
- *   // Optional => To disable change logs
- *   // changeLog: false,
+ * import { recordDeleted, recordSaved } from '..'
  *
- *   // Optional => To disable some columns from being logged
- *   // changeLog: {
- *   //   excludeColumns: (e) => {
- *   //     return [e.password]
- *   //   },
- *   // },
- * })
- * export class User {}
- * ```
+ * export function APP_Entity<entityType>(
+ * 	key: string,
+ * 	options?: EntityOptions<
+ * 		entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType
+ * 	>,
+ * ) {
+ * 	return Entity(key, {
+ * 		...options,
  *
- * ## Manual way
- * If you want to go more manual, you can import these functions and call them in your entity's lifecycle events.
- * ```ts
- * \@Entity<User>('users', {
- *   saved: async (entity, e) => {
- *     await recordSaved(entity, e)
- *   },
- *   deleted: async (entity, e) => {
- *     await recordDeleted(entity, e)
- *   },
- * })
- * export class User {}
+ * 		// changesLogs
+ * 		saved: async (entity, e) => {
+ * 			await options?.saved?.(entity, e)
+ * 			if (options?.changeLog === false) {
+ * 				// Don't log changes
+ * 			} else {
+ * 				if (isBackend()) {
+ * 					await recordSaved(entity, e, options?.changeLog)
+ * 				}
+ * 			}
+ * 		},
+ * 		deleted: async (entity, e) => {
+ * 			await options?.deleted?.(entity, e)
+ * 			if (options?.changeLog === false) {
+ * 				// Don't log changes
+ * 			} else {
+ * 				if (isBackend()) {
+ * 					await recordDeleted(entity, e, options?.changeLog)
+ * 				}
+ * 			}
+ * 		},
+ * 	})
+ * }
  * ```
  */
 export const changeLog = () => {
     return new Module({
-        name: 'changeLog',
+        key: 'changeLog',
         entities: [ChangeLog],
     });
 };

package/esm/cron/Cron.d.ts

@@ -0,0 +1,11 @@
+declare const statuses: readonly ["starting", "ended", "skipped"];
+type StatusType = (typeof statuses)[number];
+export declare class Cron {
+    id?: string;
+    topic: string;
+    startingAt: Date;
+    endedAt: Date | null;
+    result: Record<string, any>;
+    status: StatusType;
+}
+export {};

package/esm/cron/Cron.js

@@ -0,0 +1,43 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Entity, Fields } from 'remult';
+import { Role_Cron } from './Role_Cron';
+const statuses = ['starting', 'ended', 'skipped'];
+let Cron = class Cron {
+    id;
+    topic;
+    startingAt = new Date();
+    endedAt = null;
+    result = {};
+    status = 'starting';
+};
+__decorate([
+    Fields.cuid()
+], Cron.prototype, "id", void 0);
+__decorate([
+    Fields.string({ required: true })
+], Cron.prototype, "topic", void 0);
+__decorate([
+    Fields.date()
+], Cron.prototype, "startingAt", void 0);
+__decorate([
+    Fields.date({ allowNull: true })
+], Cron.prototype, "endedAt", void 0);
+__decorate([
+    Fields.json()
+], Cron.prototype, "result", void 0);
+__decorate([
+    Fields.literal(() => statuses)
+], Cron.prototype, "status", void 0);
+Cron = __decorate([
+    Entity('_ff_crons', {
+        caption: 'Crons',
+        allowApiCrud: Role_Cron.Cron_Admin,
+        defaultOrderBy: { startingAt: 'desc' },
+    })
+], Cron);
+export { Cron };

package/esm/cron/Role_Cron.d.ts

@@ -0,0 +1,3 @@
+export declare const Role_Cron: {
+    readonly Cron_Admin: "cron.admin";
+};

package/esm/cron/Role_Cron.js

@@ -0,0 +1,3 @@
+export const Role_Cron = {
+    Cron_Admin: 'cron.admin',
+};

package/esm/cron/index.d.ts

@@ -0,0 +1,3 @@
+import { Log } from '@kitql/helpers';
+export declare const key = "cron";
+export declare const log: Log;

package/esm/cron/index.js

@@ -0,0 +1,3 @@
+import { Log } from '@kitql/helpers';
+export const key = 'cron';
+export const log = new Log(key);

package/esm/cron/server/index.d.ts

@@ -1,5 +1,5 @@
 import { CronJob } from 'cron';
-import { Module } from '../../server';
+import { Module } from 'remult/server';
 export declare const jobs: Record<string, {
     job: CronJob<null, unknown> | null;
     concurrentInProgress: number;
@@ -29,18 +29,43 @@ export declare const cronTime: {
      */
     every_friday_morning: string;
 };
+/**
+ * Type for onTick function that must return a Record<string, any>
+ */
+export type CronOnTick = () => Record<string, any> | Promise<Record<string, any>>;
+/**
+ * Type for cron job parameters with enforced onTick return type
+ */
+export type CronJobParams = {
+    cronTime: string | Date;
+    onTick: CronOnTick;
+    topic: string;
+    concurrent?: number;
+    logs?: {
+        starting?: boolean;
+        ended?: boolean;
+    };
+    start?: boolean;
+    runOnInit?: boolean;
+    timeZone?: string;
+    utcOffset?: string | number;
+    onComplete?: () => void;
+};
 /**
  * usage:
  *
  * ```ts
- * import { cron, cronTime } from 'firstly/cron'
+ * import { cron, cronTime } from '..'
  *
  * export const api = firstly({
  *   modules: [
  *     cron([{
  *       topic: 'first_cron',
  *       cronTime: cronTime.every_second,
- *       onTick: () => { console.log('hello') },
+ *       onTick: () => {
+ *         console.log('hello')
+ *         return { status: 'success' }
+ *       },
  *       start: !dev, // Start in production
  *       // runOnInit: dev, // nice in dev environement
  *     }])
@@ -50,11 +75,4 @@ export declare const cronTime: {
  *
  * using [cron](https://www.npmjs.com/package/cron) library under the hood
  */
-export declare const cron: (jobsInfos: (Parameters<typeof CronJob.from>[0] & {
-    topic: string;
-    concurrent?: number;
-    logs?: {
-        starting?: boolean;
-        ended?: boolean;
-    };
-})[]) => Module;
+export declare const cron: (jobsInfos: CronJobParams[]) => Module<unknown>;

package/esm/cron/server/index.js

@@ -1,6 +1,9 @@
 import { CronJob } from 'cron';
+import { repo } from 'remult';
+import { Module } from 'remult/server';
 import { green, magenta, red, yellow } from '@kitql/helpers';
-import { Module } from '../../server';
+import { log } from '..';
+import { Cron } from '../Cron';
 export const jobs = {};
 /**
  * Link to a nice Cheatsheet TODO
@@ -31,14 +34,17 @@ export const cronTime = {
  * usage:
  *
  * ```ts
- * import { cron, cronTime } from 'firstly/cron'
+ * import { cron, cronTime } from '..'
  *
  * export const api = firstly({
  *   modules: [
  *     cron([{
  *       topic: 'first_cron',
  *       cronTime: cronTime.every_second,
- *       onTick: () => { console.log('hello') },
+ *       onTick: () => {
+ *         console.log('hello')
+ *         return { status: 'success' }
+ *       },
  *       start: !dev, // Start in production
  *       // runOnInit: dev, // nice in dev environement
  *     }])
@@ -50,7 +56,8 @@ export const cronTime = {
  */
 export const cron = (jobsInfos) => {
     const m = new Module({
-        name: 'cron',
+        key: 'cron',
+        entities: [Cron],
     });
     const logJobs = (topic, job, message, with_metadata = true, isSuccess = true) => {
         const l = [];
@@ -61,36 +68,45 @@ export const cron = (jobsInfos) => {
             l.push(`(${job.isActive ? green('running') : red('stopped')}, next at ${yellow(job.nextDate().toISO())})`);
         }
         if (isSuccess) {
-            m.log.success(l.join(' '));
+            log.success(l.join(' '));
         }
         else {
-            m.log.info(l.join(' '));
+            log.info(l.join(' '));
         }
     };
     m.initApi = async () => {
         jobsInfos.forEach((infos) => {
-            const { topic, runOnInit, logs, concurrent, ...params } = infos;
+            const { topic, runOnInit, logs, concurrent, onTick: originalOnTick, ...params } = infos;
             const concurrentToUse = concurrent ?? 1;
-            const onTickSaved = params.onTick;
-            const fullOnTick = async () => {
+            // Create a wrapper that converts the return type to void for CronJob
+            const wrappedOnTick = async () => {
                 if (jobs[topic].concurrentInProgress < concurrentToUse) {
                     jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress + 1;
+                    const rCron = await repo(Cron).insert({ topic });
                     if (logs?.starting === undefined || logs?.starting === true) {
                         logJobs(topic, job, 'starting...', false, false);
                     }
-                    // @ts-ignore
-                    await onTickSaved();
+                    const res = await originalOnTick();
+                    log.info(`[${topic}] result:`, res);
+                    rCron.result = res;
+                    rCron.endedAt = new Date();
+                    rCron.status = 'ended';
+                    await repo(Cron).save(rCron);
                     if (logs?.ended === undefined || logs?.ended === true) {
                         logJobs(topic, job, 'done');
                     }
                     jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress - 1;
                 }
                 else {
+                    const rCron = await repo(Cron).insert({ topic, status: 'skipped' });
                     logJobs(topic, job, `skipped because of concurrent limit (${yellow(concurrentToUse.toString())})`, false, false);
                 }
             };
-            params.onTick = fullOnTick;
-            const job = CronJob.from(params);
+            // Use type assertion to bypass complex generic type issues
+            const job = CronJob.from({
+                ...params,
+                onTick: wrappedOnTick,
+            });
             jobs[topic] = { job, concurrentInProgress: 0 };
             logJobs(topic, job, 'setup done');
             // If not it will be done too early

package/esm/feedback/FeedbackController.d.ts

@@ -19,15 +19,17 @@ export declare class FeedbackController {
             who?: string;
             createdAt: Date;
             public: boolean;
+            title: string;
         }[];
         labels: any;
         highlight: any;
+        title: any;
     }>;
     static createIssue(milestoneId: string, title: string, body: string, page: string): Promise<{
         id: string;
         number: number;
     }>;
-    static addCommentOnIssue(issueId: string, body: string, page: string, labels: {
+    static addCommentOnIssue(issueId: string, issueNumber: number, title: string, body: string, page: string, labels: {
         id: string;
         name: string;
     }[]): Promise<string>;

package/esm/feedback/FeedbackController.js

@@ -162,6 +162,7 @@ export class FeedbackController {
 						createdAt
 						bodyHTML
 						state
+						title
             labels(first: 25){
               nodes{
                 id
@@ -196,6 +197,7 @@ export class FeedbackController {
             bodyHTML: data.repository.issue.bodyHTML,
             createdAt: data.repository.issue.createdAt,
             public: true,
+            title: data.repository.issue.title,
         };
         items.push(firstItem);
         const comments = data.repository.issue.comments.nodes;
@@ -211,6 +213,7 @@ export class FeedbackController {
                     bodyHTML: comments[i].bodyHTML,
                     createdAt: new Date(comments[i].createdAt),
                     public: nbEye && nbEye > 0 ? true : false,
+                    title: data.repository.issue.title,
                 });
             }
         }
@@ -223,6 +226,7 @@ export class FeedbackController {
             items: items.filter((c) => c.public),
             labels: data.repository.issue.labels.nodes,
             highlight: hasWaitingForAnswerLabel,
+            title: data.repository.issue.title,
         };
         return toRet;
     }
@@ -265,9 +269,18 @@ export class FeedbackController {
         });
         const toRet = newIssue.createIssue.issue;
         await addMetaData(toRet.id, remult.user?.name, page);
+        remult.context.feedbackOptions.saved?.({
+            number: toRet.number,
+            title: title,
+            body,
+            metadata: {
+                author: JSON.stringify(remult.user?.name),
+                page,
+            },
+        });
         return toRet;
     }
-    static async addCommentOnIssue(issueId, body, page, labels) {
+    static async addCommentOnIssue(issueId, issueNumber, title, body, page, labels) {
         const inputComment = {
             subjectId: issueId,
             body,
@@ -297,6 +310,15 @@ export class FeedbackController {
             inputIssue,
         });
         await addMetaData(issueId, remult.user?.name, page);
+        remult.context.feedbackOptions.saved?.({
+            number: issueNumber,
+            title,
+            body,
+            metadata: {
+                author: JSON.stringify(remult.user?.name),
+                page,
+            },
+        });
         return 'done';
     }
     static async close(issueId, labels) {

package/esm/feedback/server/index.d.ts

@@ -1,6 +1,6 @@
-import { Module } from '../../server';
+import { ModuleFF } from '../../server';
 import type { FeedbackOptions } from '../types';
-export declare const feedback: (o: FeedbackOptions) => Module;
+export declare const feedback: (o: FeedbackOptions) => ModuleFF;
 declare module 'remult' {
     interface RemultContext {
         feedbackOptions: FeedbackOptions;

package/esm/feedback/server/index.js

@@ -1,8 +1,8 @@
 import { remult } from 'remult';
-import { Module } from '../../server';
+import { ModuleFF } from '../../server';
 import { FeedbackController } from '../FeedbackController';
 export const feedback = (o) => {
-    return new Module({
+    return new ModuleFF({
         name: 'feedback',
         controllers: [FeedbackController],
         initRequest: async (kitEvent, op) => {

package/esm/feedback/types.d.ts

@@ -10,5 +10,11 @@ export type FeedbackOptions = {
     };
     highlight_label?: string;
     create_label?: string;
+    saved?: (args: {
+        number: number;
+        title: string;
+        body: string;
+        metadata: Record<string, any>;
+    }) => Promise<void>;
 };
 export declare const FEEDBACK_OPTIONS: FeedbackOptions;

package/esm/feedback/ui/DialogIssue.svelte

@@ -6,7 +6,14 @@
 	import { page } from '$app/stores'
 
 	import { FeedbackController } from '..'
-	import { Button, cellBuildor, Field, FilterEntity, Loading, type ResolvedType } from '../..'
+	import {
+		Button,
+		cellBuildor,
+		Field,
+		FilterEntity,
+		Loading,
+		type ResolvedType,
+	} from '../../internals'
 	import Textarea from '../../ui/internals/Textarea.svelte'
 
 	export let dialogId: number
@@ -41,7 +48,14 @@
 			const result = await FeedbackController.createIssue(milestoneId, title, content, p)
 			issueNumber = result.number
 		} else {
-			await FeedbackController.addCommentOnIssue(issue.id, content, p, issue.labels)
+			await FeedbackController.addCommentOnIssue(
+				issue.id,
+				issueNumber!,
+				issue.title,
+				content,
+				p,
+				issue.labels,
+			)
 		}
 
 		content = ''

package/esm/feedback/ui/DialogIssues.svelte

@@ -11,7 +11,7 @@
 		LibIcon_Search,
 		Loading,
 		type ResolvedType,
-	} from '../..'
+	} from '../../internals'
 	import DialogIssue from './DialogIssue.svelte'
 
 	export let dialogId: number
@@ -86,7 +86,7 @@
 		>
 			<div class="flex w-full justify-center justify-items-center text-left">
 				<div class="flex-grow">
-					<span class="text-base-content/60 mr-2 inline-block w-8 text-right text-xs italic"
+					<span class="mr-2 inline-block w-8 text-right text-xs italic text-base-content/60"
 						>#{issue.number}</span
 					>
 					{@html issue.titleHTML}

package/esm/feedback/ui/DialogMilestones.svelte

@@ -1,9 +1,8 @@
 <script lang="ts">
 	import { onMount } from 'svelte'
 
-	import { FeedbackController } from '..'
-	import type { ResolvedType } from '../..'
-	import { Button, dialog, Loading } from '../..'
+	import { FeedbackController } from '../../feedback/FeedbackController'
+	import { Button, dialog, Loading, type ResolvedType } from '../../internals'
 	import DialogIssues from './DialogIssues.svelte'
 
 	export let dialogId: number

package/esm/feedback/ui/Feedback.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { dialog } from '../../'
+	import { dialog } from '../../internals'
 	import DialogMilestones from './DialogMilestones.svelte'
 
 	const list = async () => {

package/esm/formats/dates.js

@@ -1,4 +1,4 @@
-import { ff_Log } from '../';
+import { ff_Log } from '../index';
 export const dateISOToPlainDate = (iso) => {
     try {
         // const ti = Temporal.Instant.from(iso)

package/esm/formats/index.d.ts

@@ -1,4 +1,4 @@
 export { displayCurrency, displayCurrencyK, displayPercent, displayCurrencyWOSuffix, } from './numbers.js';
-export { formatNumber, extractMailInfo } from './strings.js';
+export { formatNumber, extractMailInfo, slugify, nameify, displayPhone, suffixWithS, arrToStr, mask, toTitleCase, } from './strings.js';
 export { offsetedToPlainDate, plainDateCompare, isBetween, dateISOToPlainDate } from './dates.js';
 export type { KitPlainDateRange } from './dates.js';

package/esm/formats/index.js

@@ -1,3 +1,3 @@
 export { displayCurrency, displayCurrencyK, displayPercent, displayCurrencyWOSuffix, } from './numbers.js';
-export { formatNumber, extractMailInfo } from './strings.js';
+export { formatNumber, extractMailInfo, slugify, nameify, displayPhone, suffixWithS, arrToStr, mask, toTitleCase, } from './strings.js';
 export { offsetedToPlainDate, plainDateCompare, isBetween, dateISOToPlainDate } from './dates.js';

package/esm/formats/strings.d.ts

@@ -9,3 +9,5 @@ export declare const extractMailInfo: (mail: string, withThrow?: boolean) => {
     lastName: string;
     email: string;
 };
+export declare function slugify(str: string | undefined): string | undefined;
+export declare function nameify(str: string | undefined): string | undefined;

package/esm/formats/strings.js

@@ -96,3 +96,25 @@ export const extractMailInfo = (mail, withThrow = true) => {
         email: '',
     };
 };
+export function slugify(str) {
+    if (str === undefined)
+        return undefined;
+    return str
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w.-]+/g, '-')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function nameify(str) {
+    if (str === undefined)
+        return undefined;
+    return str
+        .toLowerCase()
+        .trim()
+        .replace(/\./g, ' ')
+        .replace(/\s+/g, ' ')
+        .replace(/(?:^|\s|-)\S/g, (match) => match.toUpperCase())
+        .trim()
+        .split('@')[0];
+}

package/esm/index.d.ts

@@ -1,84 +1,3 @@
-import type { FindOptionsBase } from 'remult';
-import type { BaseEnum, BaseItem, FF_Icon } from './BaseEnum.js';
-import type { CellsInput as CellsInput_ForExport } from './cellsBuildor.js';
-import type { ColumnDeciderArgs } from './changeLog/index.js';
-import { ff_Log, FF_Role } from './common.js';
-import { storeItem } from './storeItem.js';
-import { storeList } from './storeList.js';
-import { default as Button } from './ui/Button.svelte';
-import { default as Clipboardable } from './ui/Clipboardable.svelte';
-import type { dialog } from './ui/dialog/dialog.js';
-import { default as DialogManagement } from './ui/dialog/DialogManagement.svelte';
-import { default as FormEditAction } from './ui/dialog/FormEditAction.svelte';
-import { default as Field } from './ui/Field.svelte';
-import { default as FieldGroup } from './ui/FieldGroup.svelte';
-import { default as Grid } from './ui/Grid.svelte';
-import { default as Grid2 } from './ui/Grid2.svelte';
-import { default as GridPaginate } from './ui/GridPaginate.svelte';
-import { default as GridPaginate2 } from './ui/GridPaginate2.svelte';
-import { default as Icon } from './ui/Icon.svelte';
-import { default as FieldContainer } from './ui/internals/FieldContainer.svelte';
-import { default as SelectMelt } from './ui/internals/select/SelectMelt.svelte';
-import { default as Link } from './ui/link/Link.svelte';
-import { default as LinkPlus } from './ui/link/LinkPlus.svelte';
-import { default as Loading } from './ui/Loading.svelte';
-import { default as Tooltip } from './ui/Tooltip.svelte';
-export { Field, FormEditAction, Grid, Grid2, GridPaginate, GridPaginate2, FieldGroup, Icon, Link, LinkPlus, Loading, Button, Tooltip, DialogManagement, FieldContainer, SelectMelt, Clipboardable, };
-export { FF_Role, ff_Log };
-export type { BaseEnumOptions } from './BaseEnum.js';
-export type { BaseItem };
-export type BaseItemLight = Partial<BaseItem>;
-export type { DialogMetaDataInternal } from './ui/dialog/dialog.js';
-export type CellsInput<entityType> = CellsInput_ForExport<entityType>;
-export type { Cell, VisibilityMode } from './cellsBuildor.js';
-export type { FF_FindOptions } from './storeList.js';
-export type StoreItem<T> = ReturnType<typeof storeItem<T>>;
-export type StoreList<T> = ReturnType<typeof storeList<T>>;
-export type { ResolvedType, UnArray, RecursivePartial } from './utils/types.js';
-export { FF_Fields } from './FF_Fields.js';
-export { FF_Entity } from './FF_Entity.js';
-export { FF_LogToConsole } from './SqlDatabase/FF_LogToConsole.js';
-export { BaseEnum } from './BaseEnum.js';
-export { dialog } from './ui/dialog/dialog.js';
-export { getEntityDisplayValue, isError, getFieldLinkDisplayValue, getEnum, getEnums, onDelete, } from './helper.js';
-export { buildWhere, getPlaceholder, buildSearchWhere, cellsBuildor, cellBuildor, fieldsOf, containsWords, } from './cellsBuildor.js';
-export { storeItem };
-export { storeList };
-export { displayPhone, arrToStr } from './formats/strings.js';
-export { displayCurrency } from './formats/numbers.js';
-export { tw } from './utils/tailwind.js';
-export { FilterEntity } from './virtual/FilterEntity.js';
-export { UIEntity } from './virtual/UIEntity.js';
-export { LibIcon_Empty, LibIcon_Forbidden, LibIcon_ChevronDown, LibIcon_ChevronUp, LibIcon_ChevronLeft, LibIcon_ChevronRight, LibIcon_Search, LibIcon_Check, LibIcon_MultiCheck, LibIcon_Add, LibIcon_MultiAdd, LibIcon_Edit, LibIcon_Delete, LibIcon_Cross, LibIcon_Save, LibIcon_Man, LibIcon_Woman, LibIcon_Send, LibIcon_Load, LibIcon_Settings, LibIcon_Sort, LibIcon_SortAsc, LibIcon_SortDesc, } from './ui/LibIcon.js';
-export type { FF_Icon };
-declare module 'remult' {
-    interface FieldOptions<entityType, valueType> {
-        placeholder?: string;
-        suffix?: string;
-        suffixWithS?: boolean;
-        suffixEdit?: string;
-        suffixEditWithS?: boolean;
-        styleRadioUntil?: number;
-        step?: '1' | '0.1' | '0.01';
-        href?: (item: entityType) => string;
-        findOptionsForEdit?: ((entity: entityType) => FindOptionsBase<valueType>) | FindOptionsBase<valueType>;
-        findOptionsLimit?: number;
-        createOptionWhenNoResult?: {
-            onCreateRequest: (item: entityType, strCreateNew: string) => Parameters<typeof dialog.form>;
-            onSuccess: (entity: entityType, newItem: any) => Promise<void>;
-            onError?: () => void;
-        };
-        multiSelect?: boolean;
-        skipForDefaultField?: boolean;
-    }
-    interface EntityOptions<entityType> {
-        searchableFind?: (str: string) => FindOptionsBase<entityType>;
-        displayValue?: (item: entityType) => BaseItem;
-        permissionApiCrud?: BaseEnum[] | BaseEnum;
-        permissionApiDelete?: BaseEnum[] | BaseEnum;
-        permissionApiInsert?: BaseEnum[] | BaseEnum;
-        permissionApiRead?: BaseEnum[] | BaseEnum;
-        permissionApiUpdate?: BaseEnum[] | BaseEnum;
-        changeLog?: false | ColumnDeciderArgs<entityType>;
-    }
-}
+import * as log from '@kitql/helpers';
+export { log };
+export declare const ff_Log: log.Log;