@kalel1500/kalion-js 0.7.0-beta.2

package/dist/app/tailwind-config.css

@@ -0,0 +1,61 @@
+@plugin 'flowbite/plugin';
+
+@theme {
+    --font-sans: 'Instrument Sans', ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
+    'Segoe UI Symbol', 'Noto Color Emoji';
+
+    --breakpoint-xs: 28rem;
+}
+
+/* Variantes personalizadas */
+@custom-variant dark (&:where(.dark, .dark *));
+@custom-variant sc (&:is(.sc *));
+
+/*
+  The default border color has changed to `currentColor` in Tailwind CSS v4,
+  so we've added these compatibility styles to make sure everything still
+  looks the same as it did with Tailwind CSS v3.
+
+  If we ever want to remove these styles, we need to add an explicit border
+  color utility to any element that depends on these defaults.
+*/
+@layer base {
+    *,
+    ::after,
+    ::before,
+    ::backdrop,
+    ::file-selector-button {
+        border-color: var(--color-gray-200, currentColor);
+    }
+}
+
+
+/*
+ Otros estilos:
+
+ Se pueden usar estas capas para crear clases propias:
+   @layer base {...}
+   @layer components {...}
+   @layer utilities {...}
+
+ Se puede usar el "@apply text-gray-900 bg-red-500;" para utilizar las clases de tailwind
+
+ Y también se pueden crear utilidades (que se pueden usar con variantes)
+   @utility content-auto {...}
+*/
+
+@layer utilities {
+    .kal\:shadow-xl {
+        box-shadow: 0 0 4px 1px rgba(0, 0, 0, 0.2);
+    }
+    .dark\:kal\:shadow-black-xl:where(.dark, .dark *) {
+        box-shadow: 0 0 4px 1px rgba(0, 0, 0);
+    }
+
+    .kal\:shadow-2xl {
+        box-shadow: 0 0 5px 2px rgba(0, 0, 0, 0.3);
+    }
+    .dark\:kal\:shadow-black-2xl:where(.dark, .dark *) {
+        box-shadow: 0 0 4px 1px rgba(0, 0, 0);
+    }
+}

package/dist/app/types/core/_types/index.d.ts

@@ -0,0 +1,185 @@
+import { EventCallBackMethods } from 'tabulator-tables';
+import { default as Echo } from 'laravel-echo';
+import { Translation } from '../infrastructure';
+declare global {
+    interface Window {
+        Pusher: any;
+        Echo: Echo<'reverb'>;
+    }
+}
+export type EnvVariables = {
+    readonly VITE_CONF_MINIFY?: string;
+    readonly VITE_CONF_SOURCEMAP?: string;
+    readonly VITE_CONF_USE_APPCODE_IN_SOURCE_PATH?: string;
+    readonly VITE_BROADCASTING_ENABLED?: string;
+    readonly VITE_REVERB_APP_KEY?: string;
+    readonly VITE_REVERB_HOST?: string;
+    readonly VITE_REVERB_PORT?: string;
+    readonly VITE_REVERB_SCHEME?: string;
+    readonly VITE_APP_ENV?: string;
+    readonly VITE_APP_NAME?: string;
+    readonly VITE_APP_CODE?: string;
+    readonly VITE_TS_STORAGE_VERSION?: string;
+    readonly VITE_TS_USE_BOOSTRAP_CLASSES?: string;
+};
+export interface DefaultConstants {
+    token: string | null;
+    lang: string;
+    langDouble: string;
+    defaultZoneName: string;
+    appIcon: string;
+    routeName_websockets_checkService: string;
+    routeName_queues_checkService: string;
+    readonly VITE_BROADCASTING_ENABLED: boolean;
+    readonly VITE_REVERB_APP_KEY: string | null;
+    readonly VITE_REVERB_HOST: string;
+    readonly VITE_REVERB_PORT: number;
+    readonly VITE_REVERB_SCHEME: string;
+    readonly VITE_APP_ENV: string;
+    readonly VITE_APP_NAME: string;
+    readonly VITE_APP_CODE: string;
+    readonly VITE_TS_STORAGE_VERSION: string;
+    readonly VITE_TS_USE_BOOSTRAP_CLASSES: boolean;
+}
+export interface DefaultTranslations extends Translation {
+    save: string;
+    cancel: string;
+    delete: string;
+    move_to: string;
+    close: string;
+    detail: string;
+    copy: string;
+    search_placeholder: string;
+    select_placeholder: string;
+    select_value_placeholder: string;
+    copied_text: string;
+    confirm_delete_record_NAME: string;
+    confirm_delete_FIELD_NAME: string;
+    record_RECORD_doesnt_exist_in_the_TABLE_table: string;
+    min_MIN_characters_on_search: string;
+    add_FIELD: string;
+    see_FIELD: string;
+    edit_FIELD_NAME: string;
+    the_page: string;
+    cannot_save_an_error: string;
+    incorrect_blade_format: string;
+    to_empty: string;
+    launch: string;
+    correct: string;
+    ok: string;
+    reload_page: string;
+    contact_pi_team: string;
+    unforeseen_error: string;
+    loading: string;
+    loading_dots: string;
+    search: string;
+    searching_dots: string;
+    no_results: string;
+    filter: string;
+    date: string;
+    download_completed: string;
+    fetch_error_message: string;
+    some_class_does_not_meet_the_INTERFACE_interface_contract: string;
+    it_has_been_called_a_JS_component_that_does_not_match_the_current_page: string;
+    need_NUMBER_characters: string;
+    a_loader_was_expected_on_the_page: string;
+    check_if_the_loader_was_in_a_div: string;
+    you_do_not_have_permissions_to_edit: string;
+}
+export interface FetchParams {
+    url: string;
+    type?: string;
+    ajaxParams?: {};
+    responseIsText?: boolean;
+    showLog?: boolean;
+}
+export interface FetchParamsSimple {
+    url: string;
+    type: string;
+}
+export interface CatchParams {
+    error: any;
+    title?: string;
+    text?: string;
+    html?: string;
+    reloadOnClose?: boolean;
+    footer?: string;
+    from?: string;
+}
+export interface FetchResponse {
+    success: boolean;
+    message: string;
+    data?: Record<string, any> | string;
+    detail?: string;
+}
+export interface ResponseEventFetch {
+    response: FetchResponse;
+}
+export interface FetchBroadcastingResponse extends FetchResponse {
+    data: {
+        broadcasting: FetchResponse;
+        [p: string]: any;
+    };
+}
+export type Nullish = null | undefined;
+export type StrOrNullish = string | Nullish;
+export type StrIntOrNullish = number | StrOrNullish;
+export type FetchResponseOrBroadcasting = FetchResponse | FetchBroadcastingResponse;
+export type AvailableValidations = 'optional' | 'required' | `min:${number}` | `max:${number}` | 'color' | 'array' | 'number' | 'boolean' | `required_if:${'1' | '0'}`;
+export type ValidationRules = {
+    [P: string]: AvailableValidations[] | string | number | boolean | null | undefined;
+};
+export type ValidationResponse = {
+    success: boolean;
+    messages: string[];
+    validated: Record<string, any>;
+};
+export type ValidationInternalData = {
+    success: boolean[];
+    messages: string[];
+    validated: Record<string, any>;
+};
+export type SyncOrAsync<T> = T | Promise<T> | {
+    toPromise: () => T;
+};
+export type NullHTMLButtonElement = HTMLButtonElement | null;
+export type TableSettingEvents = Partial<EventCallBackMethods>;
+export type TranslationReplacements = Record<string, StrOrNullish>;
+export declare enum Theme {
+    dark = "dark",
+    light = "light",
+    system = "system"
+}
+export type ThemeButtons = Record<Theme, HTMLElement | null>;
+export type UserPreferences = {
+    version: string;
+    theme: Theme;
+    sidebar_collapsed: boolean;
+    sidebar_state_per_page: boolean;
+};
+export type ViewData<T> = {
+    success: boolean;
+    message: string;
+    data: T;
+};
+export type Sizes = '2xs' | 'xs' | 'sm' | 'base' | 'lg' | 'lx';
+export type Colors = 'blue' | 'dark' | 'green' | 'red' | 'emerald' | 'light' | 'yellow' | 'gray';
+export type ConfigBtn = {
+    id?: string;
+    size: Sizes;
+    color: Colors;
+    slot?: string;
+    extraClasses?: string;
+    extraAttributes?: string;
+    isLink?: boolean;
+    linkUrl?: string;
+    linkBlank?: boolean;
+};
+export type ConfigIcon = {
+    outline?: boolean;
+    strokeWidth?: string;
+    size?: string;
+};
+export type ComponentType = 'btn' | 'icon';
+export type IconType = 'info' | 'save' | 'cancel' | 'delete' | 'new' | 'reload' | 'move' | 'edit';
+export type ComponentName = `btn` | `icon.${IconType}`;

package/dist/app/types/core/application/LayoutListenersUseCase.d.ts

@@ -0,0 +1,4 @@
+import { Instantiable } from '../infrastructure/utilities/general/Instantiable';
+export declare class LayoutListenersUseCase extends Instantiable {
+    __invoke(): void;
+}

package/dist/app/types/core/application/index.d.ts

@@ -0,0 +1 @@
+export * from './LayoutListenersUseCase';

package/dist/app/types/core/domain/exceptions/CannotOpenModalException.d.ts

@@ -0,0 +1,3 @@
+export declare class CannotOpenModalException extends Error {
+    constructor(msg: string);
+}

package/dist/app/types/core/domain/exceptions/CannotOpenModalWarning.d.ts

@@ -0,0 +1,3 @@
+export declare class CannotOpenModalWarning extends Error {
+    constructor(msg: string);
+}

package/dist/app/types/core/domain/exceptions/InvalidValueException.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidValueException extends Error {
+    constructor(message: string);
+}

package/dist/app/types/core/domain/index.d.ts

@@ -0,0 +1,8 @@
+export * from './exceptions/CannotOpenModalException';
+export * from './exceptions/CannotOpenModalWarning';
+export * from './exceptions/InvalidValueException';
+export * from './objects/value-objects/StringVo';
+export * from './objects/value-objects/IntVo';
+export * from './objects/value-objects/EnumVo';
+export * from './services/Test';
+export * from './services/DomService';

package/dist/app/types/core/domain/objects/value-objects/EnumVo.d.ts

@@ -0,0 +1,14 @@
+import { StrOrNullish } from '../../../_types';
+export type EnumVoParams = {
+    allowNull?: boolean;
+};
+export declare abstract class EnumVo {
+    #private;
+    protected _value: StrOrNullish;
+    protected _allowNull: boolean;
+    protected _permittedValues: string[];
+    constructor(value: StrOrNullish, params?: EnumVoParams);
+    abstract setPermittedValues(): void;
+    value(): StrOrNullish;
+    static from<T extends EnumVo>(this: new (value: StrOrNullish, params?: EnumVoParams) => T, value: StrOrNullish, params?: EnumVoParams): T;
+}

package/dist/app/types/core/domain/objects/value-objects/IntVo.d.ts

@@ -0,0 +1,12 @@
+import { StrIntOrNullish } from '../../../_types';
+export type IntVoParams = {
+    allowNull?: boolean;
+};
+export declare class IntVo {
+    #private;
+    protected _value: StrIntOrNullish;
+    protected _allowNull: boolean;
+    constructor(value: StrIntOrNullish, params?: IntVoParams);
+    value(): StrIntOrNullish;
+    static from(value: StrIntOrNullish, params?: IntVoParams): IntVo;
+}

package/dist/app/types/core/domain/objects/value-objects/StringVo.d.ts

@@ -0,0 +1,14 @@
+import { StrOrNullish } from '../../../_types';
+export type StringVoParams = {
+    allowNull?: boolean;
+    errorMessage?: string | null;
+};
+export declare class StringVo {
+    #private;
+    protected _value: StrOrNullish;
+    protected _allowNull: boolean;
+    protected _errorMessage: string | null;
+    constructor(value: StrOrNullish, params?: StringVoParams);
+    value(): StrOrNullish;
+    static from(value: StrOrNullish, params?: StringVoParams): StringVo;
+}

package/dist/app/types/core/domain/services/DomService.d.ts

@@ -0,0 +1,7 @@
+import { Instantiable } from '../../infrastructure/utilities/general/Instantiable';
+export declare class DomService extends Instantiable {
+    private $document;
+    startDarkMode(): void;
+    startSidebarState(): void;
+    startSidebarArrowsObserve(): void;
+}

package/dist/app/types/core/domain/services/Test.d.ts

@@ -0,0 +1,4 @@
+export declare class Test {
+    static printConstant(): void;
+    static printTranslation(): void;
+}

package/dist/app/types/core/domain/services/ThemeSwitcher.d.ts

@@ -0,0 +1,17 @@
+import { Instantiable } from '../../infrastructure';
+import { Theme, ThemeButtons } from '../../_types';
+export declare class ThemeSwitcher extends Instantiable {
+    private $document;
+    private mediaQuery;
+    buttons: ThemeButtons;
+    constructor();
+    getTheme(): Theme;
+    init(): void;
+    setToDark(e?: Theme): void;
+    setToLight(e?: Theme): void;
+    updateTheme(theme: Theme): void;
+    saveAndUpdate(theme: Theme): void;
+    toDarkMode(): void;
+    toLightMode(): void;
+    toSystemMode(): void;
+}

package/dist/app/types/core/infrastructure/index.d.ts

@@ -0,0 +1,17 @@
+export * from './utilities/general/Constants';
+export * from './utilities/general/Cookie';
+export * from './utilities/general/global';
+export * from './utilities/general/Html';
+export * from './utilities/general/Instantiable';
+export * from './utilities/general/LDate';
+export * from './utilities/general/LStorage';
+export * from './utilities/general/Mutation';
+export * from './utilities/general/Notify';
+export * from './utilities/general/Ttable';
+export * from './utilities/modals/SModal';
+export * from './utilities/routing/Route';
+export * from './utilities/routing/Url';
+export * from './utilities/tests/TestConstants';
+export * from './utilities/translation/Translator';
+export * from './utilities/websockets/EchoService';
+export * from './utilities/websockets/Websocket';

package/dist/app/types/core/infrastructure/utilities/components/Component.d.ts

@@ -0,0 +1,4 @@
+import { ComponentName, ConfigBtn, ConfigIcon } from '../../../_types';
+export declare class Component {
+    static get<T extends ComponentName>(component: T, config?: T extends `btn` ? ConfigBtn : ConfigIcon): string;
+}

package/dist/app/types/core/infrastructure/utilities/components/html/Btn.d.ts

@@ -0,0 +1,6 @@
+import { ConfigBtn } from '../../../../_types';
+export declare class Btn {
+    private static getHtml;
+    static tailwind({ id, size, color, slot, extraClasses, extraAttributes, isLink, linkUrl, linkBlank }: ConfigBtn): string;
+    static bootstrap({ id, size, color, slot, extraClasses, extraAttributes, isLink, linkUrl, linkBlank }: ConfigBtn): string;
+}

package/dist/app/types/core/infrastructure/utilities/components/html/Icon.d.ts

@@ -0,0 +1,5 @@
+import { ConfigIcon, IconType } from '../../../../_types';
+export declare class Icon {
+    static tailwind(name: IconType, { outline, strokeWidth, size }: ConfigIcon): string;
+    static bootstrap(name: IconType): string;
+}

package/dist/app/types/core/infrastructure/utilities/general/Constants.d.ts

@@ -0,0 +1,10 @@
+import { DefaultConstants } from '../../../_types';
+export declare class Constants<T extends DefaultConstants> {
+    private static instance;
+    constants: T;
+    private constructor();
+    static getInstance<U extends DefaultConstants>(): Constants<U>;
+    get<K extends keyof T>(key: K): T[K];
+    extend(newConfig: Partial<T>): void;
+    getConstants(): T;
+}

package/dist/app/types/core/infrastructure/utilities/general/Cookie.d.ts

@@ -0,0 +1,11 @@
+import { UserPreferences } from '../../../_types';
+export declare class Cookie {
+    private cookiePreferencesName;
+    static new(): Cookie;
+    get(name: string): string | null;
+    set(name: string, value: string, days: number): void;
+    delete(name: string): void;
+    preferences(): UserPreferences | null;
+    setPreferences(preferences: UserPreferences): void;
+    setPreference<K extends keyof UserPreferences>(key: K, value: UserPreferences[K]): void;
+}

package/dist/app/types/core/infrastructure/utilities/general/Html.d.ts

@@ -0,0 +1,4 @@
+export declare class Html {
+    static compareTailwindClassesHTML(htmlA: string, htmlB: string): boolean;
+    static compareHTMLElementsStructure(htmlA: string, htmlB: string): boolean;
+}

package/dist/app/types/core/infrastructure/utilities/general/Instantiable.d.ts

@@ -0,0 +1,5 @@
+type Constructor<T = {}> = new (...args: any[]) => T;
+export declare class Instantiable {
+    static new<T extends Constructor>(this: T, ...args: ConstructorParameters<T>): InstanceType<T>;
+}
+export {};

package/dist/app/types/core/infrastructure/utilities/general/LDate.d.ts

@@ -0,0 +1,30 @@
+import { DateTime } from 'luxon';
+import { DateTimeUnit } from 'luxon/src/datetime';
+import { DurationObjectUnits } from 'luxon/src/duration';
+type ReceivedDate = string | DateTime;
+type ReceivedNullableDate = string | DateTime | null | undefined;
+export declare class LDate {
+    #private;
+    static formats: {
+        date_startYear: string;
+        date_startDay: string;
+        date_startYear_slash: string;
+        date_startDay_slash: string;
+        date_startMonthWithoutDay_slash: string;
+        datetime_startYear: string;
+        datetime_startYear_oneWord: string;
+        time: string;
+        timeWithoutHours: string;
+        timestamp_seconds: string;
+    };
+    static now(): DateTime<true>;
+    static local(): DateTime<true>;
+    static parse(date: string): DateTime<true> | DateTime<false>;
+    static format(date: ReceivedDate, format: string): string;
+    static toSeconds(date: ReceivedDate): string;
+    static hasSame(d1: ReceivedNullableDate, d2: ReceivedNullableDate, unit: DateTimeUnit): boolean;
+    static diffNow(date: ReceivedNullableDate, unit?: keyof DurationObjectUnits): number | null | undefined;
+    static diff(d1: ReceivedNullableDate, d2: ReceivedNullableDate, unit?: keyof DurationObjectUnits): number | null | undefined;
+    static getTimeId(): string;
+}
+export {};

package/dist/app/types/core/infrastructure/utilities/general/LStorage.d.ts

@@ -0,0 +1,11 @@
+export declare class LStorage {
+    static readonly VERSION: string;
+    static readonly VERSION_KEY = "config-version";
+    static setItem(key: string, value: string): void;
+    static getItem(key: string): string | null;
+    static removeItem(key: string): void;
+    static exist(key: string): boolean;
+    static checkAndUpdateVersion(): void;
+    static isFirstConnectionInDay(): boolean;
+    static setNowAsLastConnection(): void;
+}

package/dist/app/types/core/infrastructure/utilities/general/Mutation.d.ts

@@ -0,0 +1,11 @@
+type MutationParams = {
+    elementId: string;
+    class: string;
+    whenHave: () => void;
+    whenHavent: () => void;
+};
+export declare class Mutation {
+    static observeClass(params: MutationParams): void;
+    static observe(targetNode: HTMLElement, options: MutationObserverInit, mutationCallback: () => {}): void;
+}
+export {};

package/dist/app/types/core/infrastructure/utilities/general/Notify.d.ts

@@ -0,0 +1,19 @@
+type LaunchParams = {
+    title: string;
+    body?: string;
+    openUrl?: string;
+    when: 'hidden' | 'unfocused' | 'all';
+};
+export declare class Notify {
+    #private;
+    static STORAGE: {
+        getAll(): string | null;
+        check(key: string): boolean;
+        saveNotified(key: string): void;
+        deleteNotified(): void;
+    };
+    constructor(title: string, body?: string, openUrl?: string);
+    static checkAndRequestPermission(): void;
+    static launch({ title, body, openUrl, when }: LaunchParams): void;
+}
+export {};

package/dist/app/types/core/infrastructure/utilities/general/Ttable.d.ts

@@ -0,0 +1,73 @@
+import { CellComponent, JSONRecord, LabelValue, ListEditorParams, Options, RowComponent, TabulatorFull as Tabulator } from 'tabulator-tables';
+import { FetchParamsSimple, NullHTMLButtonElement, TableSettingEvents, ValidationRules } from '../../../_types';
+export declare class Ttable {
+    readonly tableId: string | HTMLElement;
+    table: Tabulator;
+    isEditable: boolean;
+    readonly orderFieldName: string;
+    constructor(tableId: string | HTMLElement, options: Options, settingEvents: TableSettingEvents, orderFieldName?: string);
+    isEditableCell(cell: CellComponent): boolean;
+    addClassEditableOnEditableCells(row: RowComponent): void;
+    static formatListValuesToLabelValueStructure(values: JSONRecord): LabelValue[];
+    /**
+     * -----------------------------------------------------------------------------------------------------------------
+     * ----- VARIABLES Y FUNCIONES GENERICAS Y COFNIGURACIONES PREDETERMINADAS------------------------------------------
+     */
+    static defaultSettings: Options;
+    static buttons: {
+        linkBtnInfo: (title: string, url: string, blank: boolean) => string;
+        linkBtnEdit: (title: string, url: string) => string;
+        linkTextEdit: (title: string, url: string) => string;
+        btnInfo: (title: string) => string;
+        btnSave: (title: string, showText?: boolean) => string;
+        btnCancel: (title: string, showText?: boolean) => string;
+        btnDelete: (title: string, showText?: boolean) => string;
+        btnNew: (title: string, id?: string) => string;
+        btnReload: (title: string) => string;
+        btnMove: (title: string) => string;
+    };
+    static formatterParams_lookupBoolean: {
+        undefined: string;
+        null: string;
+        0: string;
+        1: string;
+    };
+    static formatterParams_lookupSimple(values: JSONRecord): JSONRecord;
+    static defaultListEditorParams: ListEditorParams;
+    static editorParams_listBoolean: ListEditorParams;
+    static editorParams_list(values: JSONRecord, { searchable }?: {
+        searchable: boolean;
+    }): ListEditorParams;
+    static editorParams_listFix(values: JSONRecord): ListEditorParams;
+    static editorParams_listBig(values: JSONRecord): ListEditorParams;
+    static headerFilterParams_listBoolean: {
+        values: {
+            0: string;
+            1: string;
+        };
+    };
+    static headerFilterParams_listSimple(values: JSONRecord | any[]): ListEditorParams;
+    static headerFilterParams_listBig(values: JSONRecord): ListEditorParams;
+    /**
+     * -----------------------------------------------------------------------------------------------------------------
+     * ----- OTRAS FUNCIONES -------------------------------------------------------------------------------------------
+     */
+    defaultListenerBtnEdit(btnEdit: NullHTMLButtonElement, btnCancelEdit: NullHTMLButtonElement): void;
+    defaultListenerBtnCancel(btnEdit: NullHTMLButtonElement, btnCancelEdit: NullHTMLButtonElement): void;
+    defaultListenerBtnAddRow(data?: {}): void;
+    saveDataOnRowMovedEvent(row: RowComponent, { url, type }: FetchParamsSimple): Promise<void>;
+    changeColorsOnRowMovedEvent(row: RowComponent): Promise<{
+        isEdited: boolean;
+    }>;
+    saveOrderOfAllData({ url, type }: FetchParamsSimple): Promise<void>;
+    static defaultActionSave(cell: CellComponent, url: string, rules: ValidationRules, preventReplaceData?: boolean): Promise<boolean>;
+    static defaultActionDelete(cell: CellComponent, url: string, { title, html, preventReplaceData, }: {
+        title?: string;
+        html?: string;
+        preventReplaceData?: boolean;
+    }): Promise<boolean>;
+    static defaultActionCancel(cell: CellComponent): void;
+    defaultFormatterCellActions(cell: CellComponent): string;
+    static customFormatterLookup(cell: CellComponent, formatterParams: Record<any, any>): string;
+    static getObjectWithThisValue(__this: any): {};
+}

package/dist/app/types/core/infrastructure/utilities/general/global.d.ts

@@ -0,0 +1,38 @@
+import { CatchParams, FetchParams, FetchResponse, ValidationResponse, ValidationRules } from '../../../_types';
+type Value = string | string[];
+type Key = string | string[] | null;
+export declare class g {
+    static errorModalIsShowed: boolean;
+    static isNotNull(variable: any): boolean;
+    static isUndefined(variable: any): boolean;
+    static escapeHtml(html: string): string;
+    static handleGlobalError(error?: Error): boolean;
+    static newFetch<T = FetchResponse>({ url, type, ajaxParams, responseIsText, showLog, }: FetchParams): Promise<T>;
+    static catchCode({ error, title, text, html, reloadOnClose, footer, from, }: CatchParams): void;
+    static sleep(ms: number): Promise<unknown>;
+    static strIsEmpty(str: any): boolean;
+    static isEmpty(value: any): boolean;
+    static deleteArrayItemsWhere(array: any[], filterFunc: (e: any) => boolean, nameField: string): any[];
+    static valueFailsRequiredValidation(value: any): boolean;
+    static validate(data: Record<string, any>, rules: ValidationRules): ValidationResponse;
+    static strIncludesAny(str: string, values: string[]): boolean;
+    static eventClosest(event: Event, selectors: string): HTMLElement | null;
+    static showPageLoader(): void;
+    static removePageLoader(): void;
+    static reloadPage(): void;
+    static startTooltips(): void;
+    static addSpinner(selectors: string | HTMLElement | NodeListOf<HTMLElement> | null, size?: 'sm' | 'md'): void;
+    static removeSpinner(selectors: string | HTMLElement | NodeListOf<HTMLElement> | null): void;
+    static consoleInfo(message?: any): void;
+    static isTruthy(value: any): boolean;
+    static isFalsy(value: any): boolean;
+    static isNullish(value: any): boolean;
+    static dataGet(target: any, key: Key, defaultValue?: any): any;
+    static explodePluckParameters(value: Value, key: Key): [Value, Key];
+    static pluck(array: Record<any, any>[], value: Key): any[];
+    static pluck(array: Record<any, any>[], value: Key, key: Key): Record<any, any>;
+    static slugify(text: string, separator?: string): string;
+    static getHiddenClass(): "d-none" | "hidden";
+    static mergeTailwindClasses(defaultCls: string, extraCls: string): string;
+}
+export {};