firstly 0.0.1 → 0.0.2

package/esm/feedback/ui/DialogIssues.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        dialogId: number;
+        milestoneNumber: number;
+        milestoneId: string;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type DialogIssuesProps = typeof __propDef.props;
+export type DialogIssuesEvents = typeof __propDef.events;
+export type DialogIssuesSlots = typeof __propDef.slots;
+export default class DialogIssues extends SvelteComponent<DialogIssuesProps, DialogIssuesEvents, DialogIssuesSlots> {
+}
+export {};

package/esm/feedback/ui/DialogMilestones.svelte

@@ -0,0 +1,38 @@
+<script>import { onMount } from "svelte";
+import { FeedbackController } from "..";
+import { Button, dialog, Loading } from "../..";
+import DialogIssues from "./DialogIssues.svelte";
+export let dialogId;
+const rmvWarning = dialogId;
+let state = "loading";
+let milestones = [];
+onMount(async () => {
+  milestones = await FeedbackController.getMilestones();
+  state = "done";
+});
+</script>
+
+<div class="mb-4 grid gap-4">
+  {#each milestones as milestone}
+    <Button
+      on:click={() =>
+        dialog.show({
+          component: DialogIssues,
+          classes: { root: 'overflow-auto w-5/6 h-5/6' },
+          props: { milestoneNumber: milestone.number, milestoneId: milestone.id },
+          detail: { caption: milestone.title },
+        })}
+      class="btn-neutral"
+    >
+      {milestone.title}
+    </Button>
+  {:else}
+    {#if state === 'loading'}
+      <Loading class="h-12"></Loading>
+      <Loading class="h-12"></Loading>
+      <Loading class="h-12"></Loading>
+    {:else}
+      <p>No milestones found / Filter too strict!</p>
+    {/if}
+  {/each}
+</div>

package/esm/feedback/ui/DialogMilestones.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        dialogId: number;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type DialogMilestonesProps = typeof __propDef.props;
+export type DialogMilestonesEvents = typeof __propDef.events;
+export type DialogMilestonesSlots = typeof __propDef.slots;
+export default class DialogMilestones extends SvelteComponent<DialogMilestonesProps, DialogMilestonesEvents, DialogMilestonesSlots> {
+}
+export {};

package/esm/feedback/ui/Feedback.svelte

@@ -0,0 +1,12 @@
+<script>import { dialog } from "../../";
+import DialogMilestones from "./DialogMilestones.svelte";
+const list = async () => {
+  await dialog.show({
+    component: DialogMilestones,
+    classes: { root: "overflow-auto w-5/6 h-5/6" },
+    detail: { caption: "Feedback" }
+  });
+};
+</script>
+
+<button class="text-secondary" on:click={list}>Feedback</button>

package/esm/feedback/ui/Feedback.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+    exports?: {} | undefined;
+    bindings?: string | undefined;
+};
+export type FeedbackProps = typeof __propDef.props;
+export type FeedbackEvents = typeof __propDef.events;
+export type FeedbackSlots = typeof __propDef.slots;
+export default class Feedback extends SvelteComponent<FeedbackProps, FeedbackEvents, FeedbackSlots> {
+}
+export {};

package/esm/formats/dates.d.ts

@@ -0,0 +1,18 @@
+export declare const dateISOToPlainDate: (iso: string) => string;
+export declare const offsetedToPlainDate: (dt: Date) => string;
+export type KitPlainDateRange = {
+    from: string;
+    to: string;
+};
+/**
+ * in `range`, `from` is inclusive and `to` is exclusive
+ */
+export declare const isBetween: (dt: string, range: KitPlainDateRange) => boolean;
+export declare const plainDateCompare: (dt: string, op: {
+    $gt?: string;
+    /** From */
+    $gte?: string;
+    /** to */
+    $lt?: string;
+    $lte?: string;
+}) => boolean;

package/esm/formats/dates.js

@@ -0,0 +1,35 @@
+import { logFirstly } from '../';
+export const dateISOToPlainDate = (iso) => {
+    try {
+        // const ti = Temporal.Instant.from(iso)
+        // return ti.toZonedDateTimeISO('UTC').toPlainDate()
+        if (iso.includes('T')) {
+            return iso.split('T')[0];
+        }
+    }
+    catch (error) { }
+    const msg = `fn dateISOToPlainDate -> "${iso}" is not valid iso`;
+    logFirstly.error(msg);
+    throw new Error(msg);
+};
+export const offsetedToPlainDate = (dt) => {
+    const userTimezoneOffset = dt.getTimezoneOffset() * 60000;
+    const adjustedDate = new Date(dt.getTime() - userTimezoneOffset);
+    return adjustedDate.toISOString().split('T')[0];
+    // Huge performance issue! (check: filterAndRowSpan)
+    // const ti = Temporal.Instant.from(adjustedDate.toISOString())
+    // return ti.toZonedDateTimeISO('UTC').toPlainDate()
+};
+/**
+ * in `range`, `from` is inclusive and `to` is exclusive
+ */
+export const isBetween = (dt, range) => {
+    return plainDateCompare(dt, { $gte: range.from, $lt: range.to });
+};
+export const plainDateCompare = (dt, op) => {
+    const gt = op.$gt ? new Date(op.$gt) < new Date(dt) : true;
+    const gte = op.$gte ? new Date(op.$gte) <= new Date(dt) : true;
+    const lt = op.$lt ? new Date(dt) < new Date(op.$lt) : true;
+    const lte = op.$lte ? new Date(dt) <= new Date(op.$lte) : true;
+    return gt && gte && lt && lte;
+};

package/esm/formats/index.d.ts

@@ -0,0 +1,4 @@
+export { displayCurrency, displayCurrencyK, displayPercent, displayCurrencyWOSuffix, } from './numbers.js';
+export { formatNumber, extractMailInfo } from './strings.js';
+export { offsetedToPlainDate, plainDateCompare, isBetween, dateISOToPlainDate } from './dates.js';
+export type { KitPlainDateRange } from './dates.js';

package/esm/formats/index.js

@@ -0,0 +1,3 @@
+export { displayCurrency, displayCurrencyK, displayPercent, displayCurrencyWOSuffix, } from './numbers.js';
+export { formatNumber, extractMailInfo } from './strings.js';
+export { offsetedToPlainDate, plainDateCompare, isBetween, dateISOToPlainDate } from './dates.js';

package/esm/formats/numbers.d.ts

@@ -0,0 +1,4 @@
+export declare function displayCurrencyWOSuffix(_entity: any, value: number | undefined): string;
+export declare function displayCurrency(_entity: any, value: number | undefined): string;
+export declare function displayCurrencyK(_entity: any, value: number | undefined): string;
+export declare function displayPercent(value: number | undefined): string;

package/esm/formats/numbers.js

@@ -0,0 +1,34 @@
+import { formatNumber } from './strings.js';
+export function displayCurrencyWOSuffix(_entity, value) {
+    if (value === undefined)
+        return '-';
+    return new Intl.NumberFormat('fr', { currency: 'EUR', style: 'currency' })
+        .format(value ?? 0)
+        .replace('€', '')
+        .trim();
+}
+export function displayCurrency(_entity, value) {
+    if (value === undefined)
+        return '- €';
+    return new Intl.NumberFormat('fr', { currency: 'EUR', style: 'currency' }).format(value ?? 0);
+}
+export function displayCurrencyK(_entity, value) {
+    if (value === undefined)
+        return '- €';
+    if (Math.abs(value) < 1000) {
+        return displayCurrency(_entity, value);
+    }
+    return new Intl.NumberFormat('fr', {
+        currency: 'EUR',
+        style: 'currency',
+        maximumFractionDigits: 0,
+    })
+        .format(value / 1000)
+        .replace('€', 'k€');
+}
+export function displayPercent(value) {
+    if (value === undefined) {
+        return '- %';
+    }
+    return formatNumber(value) + ' %';
+}

package/esm/formats/strings.d.ts

@@ -0,0 +1,11 @@
+export declare const formatNumber: (number: number, digitNumber?: number) => string;
+export declare function displayPhone(_entity: any, value: string | undefined): string;
+export declare const arrToStr: (arr: string | undefined | (string | undefined)[]) => string;
+export declare const mask: (str: string | undefined) => string;
+export declare const suffixWithS: (value: number, str: string) => string;
+export declare const toTitleCase: (str: string) => string;
+export declare const extractMailInfo: (mail: string, withThrow?: boolean) => {
+    firstName: string;
+    lastName: string;
+    email: string;
+};

package/esm/formats/strings.js

@@ -0,0 +1,109 @@
+export const formatNumber = (number, digitNumber = 2) => {
+    if (number === undefined || number === null || isNaN(number)) {
+        const value = 0;
+        return value.toFixed(digitNumber);
+    }
+    return number
+        .toFixed(digitNumber) // decimal digits
+        .replace('.', ',') // replace decimal point character with ,
+        .replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1 ');
+};
+export function displayPhone(_entity, value) {
+    return formatPhone(value ?? '');
+}
+const formatPhone = (phone) => {
+    if (!phone) {
+        return '';
+    }
+    return phone;
+    // TODO: Let's be smart one day... and add a ton of tests!
+    // const replaced = phone.replaceAll(' ', '').replaceAll('.', '')
+    // let formatted: string = replaced
+    // if (replaced.charAt(0) === '+') {
+    // 	return formatted
+    // } else if (replaced.slice(0, 2) === '00') {
+    // 	return `+${formatted.slice(2)}`
+    // } else if (replaced.length > 10) {
+    // 	formatted = replaced.slice(0, 10)
+    // }
+    // return `+33${formatted.slice(1)}`
+};
+export const arrToStr = (arr) => {
+    if (!arr)
+        return '';
+    if (typeof arr === 'string')
+        return arr;
+    return arr.filter((c) => c).join(' - ');
+};
+export const mask = (str) => {
+    if (str === undefined)
+        return '';
+    return str.slice(0, -4).replace(/./g, '*') + str.slice(-4);
+};
+export const suffixWithS = (value, str) => {
+    if (value) {
+        if (value <= 1) {
+            return `${str}`;
+        }
+        else {
+            if (str.endsWith('²')) {
+                return `${str}`;
+            }
+            else {
+                return `${str}s`;
+            }
+        }
+    }
+    else {
+        return `${str}`;
+    }
+};
+export const toTitleCase = (str) => {
+    // Replace dashes and underscores with spaces
+    const stringWithSpaces = str.replace(/[-_]/g, ' ');
+    // Add a space before each capital letter (for camelCase)
+    const titleCaseString = stringWithSpaces.replace(/([a-z])([A-Z])/g, '$1 $2');
+    // Capitalize the first letter of each word and join them back
+    const words = titleCaseString.split(' ');
+    const titleCaseWords = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+    return titleCaseWords.join(' ');
+};
+const rmvChars = (str, chars = ['<', '>', ',']) => {
+    return chars.reduce((acc, char) => acc.replaceAll(char, ''), str).trim();
+};
+export const extractMailInfo = (mail, withThrow = true) => {
+    if (!mail) {
+        if (withThrow) {
+            throw new Error('No mail provided');
+        }
+        return {
+            firstName: '',
+            lastName: '',
+            email: '',
+        };
+    }
+    const regex = /(.+)\s(.+)\s<(.+)>/i;
+    const match = mail.match(regex);
+    if (match) {
+        const firstName = toTitleCase(rmvChars(match[1].trim())).replaceAll(' ', '-');
+        const lastName = rmvChars(match[2].trim()).toUpperCase();
+        const email = rmvChars(match[3]).toLowerCase();
+        return { firstName, lastName, email };
+    }
+    if (mail.includes('@')) {
+        const clean = rmvChars(mail);
+        const [left] = clean.split('@');
+        const names = left.split('.');
+        return {
+            firstName: names.length > 1 ? toTitleCase(names[0]).replaceAll(' ', '-') : '',
+            lastName: (names.length > 1 ? names[1] : names[0]).toUpperCase(),
+            email: rmvChars(mail).toLowerCase(),
+        };
+    }
+    const clean = rmvChars(mail);
+    return {
+        firstName: '',
+        lastName: clean,
+        email: '',
+    };
+};

package/esm/handle/index.d.ts

@@ -0,0 +1,7 @@
+import type { Handle } from '@sveltejs/kit';
+import type { RemultSveltekitServer } from 'remult/remult-sveltekit';
+import type { Module } from '../api';
+export declare const firstly: (api: {
+    server: RemultSveltekitServer;
+    modulesSorted: Module[];
+}) => Handle;

package/esm/handle/index.js

@@ -0,0 +1,40 @@
+import { sequence } from '@sveltejs/kit/hooks';
+// const log = new Log('firstly')
+/**
+ * to bring `remult.` on the server side (after this hook, you have assess to `remult.user` for example !)
+ */
+const internalRemultHandle = (api, modules) => async (h) => {
+    return await api.withRemult(h.event, async () => {
+        if (modules !== undefined) {
+            for (let i = 0; i < modules.length; i++) {
+                const early = modules[i].earlyReturn;
+                if (early) {
+                    const ret = await early(h);
+                    if (ret.early) {
+                        return ret.resolve;
+                    }
+                }
+            }
+        }
+        return await h.resolve(h.event);
+    });
+};
+export const firstly = ({ server, modulesSorted }) => {
+    const handlesPre = [];
+    const handlesPost = [];
+    for (let i = 0; i < modulesSorted.length; i++) {
+        if (modulesSorted[i].handlePreRemult) {
+            handlesPre.push(modulesSorted[i].handlePreRemult);
+        }
+        if (modulesSorted[i].handlePosRemult) {
+            handlesPost.push(modulesSorted[i].handlePosRemult);
+        }
+    }
+    return sequence(
+    // First
+    sequence(...handlesPre), 
+    // Then
+    internalRemultHandle(server, modulesSorted), 
+    // Finally
+    sequence(...handlesPost));
+};

package/esm/helper.d.ts

@@ -0,0 +1,50 @@
+import { type ErrorInfo, type FieldMetadata, type Repository } from 'remult';
+import { type KitBaseItem } from './index.js';
+export declare function isError<T>(object: any): object is ErrorInfo<T>;
+export declare const getFirstInterestingField: <Entity>(repo: Repository<Entity>) => FieldMetadata<any, Entity>;
+export declare const getEntityDisplayValue: <Entity>(repo: Repository<Entity>, row: Entity) => KitBaseItem;
+export declare const getFieldLinkDisplayValue: (field: FieldMetadata, row: any) => import("./KitBaseEnum.js").KitBaseEnumOptions & {
+    id: string;
+    captionSub?: string | (string | undefined)[] | undefined;
+    href?: string | undefined;
+    repo?: Repository<any> | undefined;
+    sub?: {
+        captionPre?: string | undefined;
+        repo?: Repository<any> | undefined;
+        item?: any;
+    } | undefined;
+} & {
+    href: string;
+};
+export declare const getEntityDisplayValueFromField: (field: FieldMetadata, row: any) => KitBaseItem & {
+    href: string;
+};
+export type MetaTypeRelation = {
+    kind: 'relation';
+    subKind: 'reference' | 'toOne' | 'toMany';
+    repoTarget: Repository<any>;
+    field: FieldMetadata;
+};
+type MetaTypeEnum = {
+    kind: 'enum';
+    subKind: 'single' | 'multi';
+    values: KitBaseItem[];
+    field: FieldMetadata;
+};
+type MetaTypePrimitive = {
+    kind: 'primitive';
+    subKind: string;
+    field: FieldMetadata;
+};
+type MetaTypeSlot = {
+    kind: 'slot';
+    subKind: '???';
+};
+export type FieldMetaType = MetaTypeRelation | MetaTypeEnum | MetaTypePrimitive | MetaTypeSlot;
+export declare const getFieldMetaType: (field?: FieldMetadata) => FieldMetaType;
+export declare const displayWithDefaultAndSuffix: (field: FieldMetadata<any, any> | undefined, value: any) => string;
+/**
+ * same as `dbNamesOf` but with `tableName` set to `true` by default
+ */
+export declare const kitDbNamesOf: <Entity>(repo: import("remult/src/remult3/RepositoryImplementation.js").EntityMetadataOverloads<Entity>, wrapIdentifierOrOptions?: ((name: string) => string) | import("remult").dbNamesOfOptions | undefined) => Promise<import("remult").EntityDbNames<Entity>>;
+export {};

package/esm/helper.js

@@ -0,0 +1,118 @@
+import { dbNamesOf, getEntityRef, } from 'remult';
+import { getRelationFieldInfo } from 'remult/internals';
+import { suffixWithS } from './formats/strings.js';
+import {} from './index.js';
+export function isError(object) {
+    return object;
+}
+export const getFirstInterestingField = (repo) => {
+    const fields = repo.metadata.fields.toArray();
+    for (let i = 0; i < fields.length; i++) {
+        // Let's find the most relevant field to display...
+        if (fields[i].key !== 'id' &&
+            fields[i].key !== 'createdAt' &&
+            fields[i].options.skipForDefaultField !== true) {
+            return fields[i];
+        }
+    }
+    return fields[0];
+};
+export const getEntityDisplayValue = (repo, row) => {
+    if (repo.metadata.options.displayValue) {
+        return repo.metadata.options.displayValue(row);
+    }
+    const field = getFirstInterestingField(repo);
+    // REMULT P3 JYC: If it's an enum, it's not working...
+    return { caption: row ? field.displayValue(row) : '-', id: '' };
+};
+export const getFieldLinkDisplayValue = (field, row) => {
+    const caption = field.displayValue(row);
+    let href = '';
+    if (field.options.href) {
+        href = field.options.href(row);
+    }
+    return { id: '', caption, href };
+};
+export const getEntityDisplayValueFromField = (field, row) => {
+    if (row === null || row === undefined) {
+        return { href: '/', id: '', caption: '-' };
+    }
+    const repo = getEntityRef(row).repository;
+    return { href: '', ...getEntityDisplayValue(repo, row) };
+};
+// or it's a slot or it will return the field
+export const getFieldMetaType = (field) => {
+    if (field === undefined) {
+        return { kind: 'slot', subKind: '???' };
+    }
+    // is it a relation?
+    const fieldRelationInfo = getRelationFieldInfo(field);
+    if (fieldRelationInfo) {
+        return {
+            kind: 'relation',
+            subKind: fieldRelationInfo.type,
+            repoTarget: fieldRelationInfo.toRepo,
+            field,
+        };
+    }
+    if (field.options?.inputType === 'selectArrayEnum') {
+        return {
+            kind: 'enum',
+            subKind: 'multi',
+            // // @ts-ignore
+            // values: getEnums(field.target) as KitBaseItem[],
+            // @ts-ignore
+            values: field.options.valueConverter.values,
+            field,
+        };
+    }
+    // REMULT P2 JYC: Any idea to know if it's an enum? and extract values?
+    // const ttt = getValueList(field)
+    // console.log(`ttt`, ttt)
+    // Error: ValueType not yet initialized, did you forget to call @ValueListFieldType on function String()
+    // is it an enum?
+    // @ts-ignore
+    if (field.options?.valueConverter?.values) {
+        // console.log(`field.options.valueConverter.values`, field.options.valueConverter.values)
+        return {
+            kind: 'enum',
+            subKind: 'single',
+            // @ts-ignore
+            values: field.options.valueConverter.values,
+            field,
+        };
+    }
+    // it's a primitive
+    return { kind: 'primitive', subKind: field.inputType ?? 'text', field };
+};
+export const displayWithDefaultAndSuffix = (field, value) => {
+    const toRet = [];
+    // TODO: This method should be reviewed. Specifically, server expression & Field.date have
+    // valueConverter by defualt, so we can't use displayValue if checking for valueConverter
+    // Hummm... JYC: I didn't understand the above comment.
+    if (field && field.valueConverter?.displayValue && !field.isServerExpression) {
+        toRet.push(field.valueConverter?.displayValue(value) ?? '-');
+    }
+    else {
+        // toRet.push(value ?? '-')
+        toRet.push(field?.displayValue ? field?.displayValue({ [field.key]: value }) : value ?? '-');
+    }
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (field?.options.suffix) {
+        if (field.options.suffixWithS) {
+            toRet.push(suffixWithS(value, field.options.suffix));
+        }
+        else {
+            toRet.push(field.options.suffix);
+        }
+    }
+    return toRet.join(' ');
+};
+/**
+ * same as `dbNamesOf` but with `tableName` set to `true` by default
+ */
+export const kitDbNamesOf = async (...p) => {
+    return dbNamesOf(p[0], { tableName: true, ...p[1] });
+};

package/esm/index.d.ts

@@ -0,0 +1,103 @@
+import type { FindOptionsBase, Repository } from 'remult';
+import 'remult';
+import type { RequestEvent } from '@sveltejs/kit';
+import { Log } from '@kitql/helpers';
+import type { KitBaseEnum, KitBaseEnumOptions, KitIcon } from './KitBaseEnum.js';
+import type { KitCellsInput as KitCellsInputForExport } from './kitCellsBuildor.js';
+import { kitStoreItem } from './kitStoreItem.js';
+import { kitStoreList } from './kitStoreList.js';
+import { default as Button } from './ui/Button.svelte';
+import { default as Clipboardable } from './ui/Clipboardable.svelte';
+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 GridPaginate } from './ui/GridPaginate.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 declare const logFirstly: Log;
+export declare const KitRole: {
+    Admin: string;
+};
+export { Field, FormEditAction, Grid, GridPaginate, FieldGroup, Icon, Link, LinkPlus, Loading, Button, Tooltip, DialogManagement, FieldContainer, SelectMelt, Clipboardable, };
+export { dialog } from './ui/dialog/dialog.js';
+export type { DialogMetaDataInternal } from './ui/dialog/dialog.js';
+export { KitBaseEnum, getEnum, getEnums } from './KitBaseEnum.js';
+export type { KitBaseEnumOptions } from './KitBaseEnum.js';
+export { KitFields } from './KitFields.js';
+export { KitEntity } from './KitEntity.js';
+export { LogToConsoleCustom } from './SqlDatabase/LogToConsoleCustom.js';
+export { getEntityDisplayValue, isError, kitDbNamesOf, getFieldLinkDisplayValue } from './helper.js';
+export { buildWhere, getPlaceholder, buildSearchWhere, kitCellsBuildor, kitCellBuildor, fieldsOf, } from './kitCellsBuildor.js';
+export { kitStoreItem };
+export { kitStoreList };
+export type KitCellsInput<entityType> = KitCellsInputForExport<entityType>;
+export type { KitCell, VisibilityMode } from './kitCellsBuildor.js';
+export type { FindOptionsPlus } from './kitStoreList.js';
+export type KitBaseItem = KitBaseEnumOptions & {
+    id: string;
+    captionSub?: string | (string | undefined)[];
+    href?: string;
+    repo?: Repository<any>;
+    sub?: {
+        captionPre?: string;
+        repo?: Repository<any>;
+        item?: any;
+    };
+};
+export type KitStoreItem<T> = ReturnType<typeof kitStoreItem<T>>;
+export type KitStoreList<T> = ReturnType<typeof kitStoreList<T>>;
+export type KitBaseItemLight = Partial<KitBaseItem>;
+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 { KitIcon };
+export { displayPhone, arrToStr } from './formats/strings.js';
+export { displayCurrency } from './formats/numbers.js';
+export { tw } from './utils/tailwind.js';
+export { litOrStr } from './utils/types.js';
+export type { ResolvedType, UnArray } from './utils/types.js';
+declare module 'remult' {
+    interface RemultContext {
+        url: URL;
+        setHeaders(headers: Record<string, string>): void;
+        setCookie(...args: Parameters<RequestEvent['cookies']['set']>): void;
+        deleteCookie(...args: Parameters<RequestEvent['cookies']['delete']>): void;
+    }
+    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?: boolean;
+        multiSelect?: boolean;
+        skipForDefaultField?: boolean;
+    }
+    interface EntityOptions<entityType> {
+        searchableFind?: (str: string) => FindOptionsBase<entityType>;
+        displayValue?: (item: entityType) => KitBaseItem;
+        permissionApiCrud?: KitBaseEnum[] | KitBaseEnum;
+        permissionApiDelete?: KitBaseEnum[] | KitBaseEnum;
+        permissionApiInsert?: KitBaseEnum[] | KitBaseEnum;
+        permissionApiRead?: KitBaseEnum[] | KitBaseEnum;
+        permissionApiUpdate?: KitBaseEnum[] | KitBaseEnum;
+    }
+    interface UserInfo {
+        session: {
+            id: string;
+            expiresAt: Date;
+        };
+    }
+}