@mcurros2/microm 1.1.1-0

package/dist/index.d.ts

@@ -0,0 +1,3543 @@
+import { AlertProps, DefaultMantineColor, Variants, StepperProps, MantineTheme, TextareaProps, TextInputProps, MantineNumberSize, MantineColor, PasswordInputProps, NotificationProps, CheckboxProps, ProgressProps, ButtonProps, ActionIconProps, NumberInputProps, ImageProps, MultiSelectProps, SelectItem, BadgeVariant, MantineSize, CardProps, OverlayProps, TransitionProps, AccordionProps, PinInputProps, SwitchProps, Radio, SelectProps, GroupProps, AvatarProps, AutocompleteItem, AutocompleteProps, DefaultProps, BadgeProps } from "@mantine/core";
+import React, { JSXElementConstructor, ReactElement, ReactNode, PropsWithChildren, ComponentType, useState, Dispatch, SetStateAction, KeyboardEvent, ComponentPropsWithoutRef, RefObject } from "react";
+import { hasLength, isInRange, isNotEmpty, matches, UseFormReturnType } from "@mantine/form";
+import { LooseKeys } from "@mantine/form/lib/types";
+import { IconProps } from "@tabler/icons-react";
+import { ModalSettings } from "@mantine/modals/lib/context";
+import { PrismProps } from "@mantine/prism";
+import { DateInputProps, TimeInputProps, CalendarProps } from "@mantine/dates";
+import { DropzoneProps } from "@mantine/dropzone";
+import { AccordionVariant } from "@mantine/core/lib/Accordion/Accordion.types";
+import { SpotlightAction } from "@mantine/spotlight";
+import { Loader, LoaderOptions } from "@googlemaps/js-api-loader";
+import { Cluster, ClusterStats, Marker, MarkerClustererOptions } from "@googlemaps/markerclusterer";
+export type Value = string | number | Date | boolean | string[] | null;
+export type ValuesObject = Record<string, Value>;
+export type ValuesRecord = Value[];
+export type SQLType = 'char' | 'nchar' | 'varchar' | 'nvarchar' | 'text' | 'ntext' | 'tinyint' | 'smallint' | 'int' | 'bigint' | 'float' | 'decimal' | 'real' | 'bit' | 'money' | 'datetime2' | 'datetime' | 'smalldatetime' | 'date' | 'binary' | 'varbinary' | 'image' | 'time';
+export interface DataResult {
+    Header: string[];
+    typeInfo: SQLType[];
+    records: ValuesRecord[];
+}
+export interface DBStatus {
+    Status: number;
+    Message: string;
+}
+export enum DBStatusCodes {
+    "OK" = 0,
+    "AUTONUM" = 15,
+    "RECORD_CHANGED" = 4,
+    "ERROR" = 11
+}
+export interface DBStatusResult {
+    Failed: boolean;
+    AutonumReturned: boolean;
+    Results: DBStatus[];
+}
+export function isDBStatusResult(data: any): data is DBStatusResult;
+export interface IDataStorage {
+    saveData(app_id: string, key: string, data: unknown): Promise<void>;
+    readData(app_id: string, key: string): Promise<unknown | null>;
+    deleteData(app_id: string, key: string): Promise<void>;
+}
+export class DataStorage implements IDataStorage {
+    #private;
+    constructor(storage_type?: 'sessionStorage' | 'localStorage', storage_name?: string);
+    saveData<T>(app_id: string, key: string, data: T): Promise<void>;
+    readData<T>(app_id: string, key: string): Promise<T | null>;
+    deleteData(app_id: string, key: string): Promise<void>;
+}
+export interface ImpDataResult {
+    ProcessedCount: number;
+    SuccessCount: number;
+    ErrorCount: number;
+    Errors: Record<number, string>;
+}
+export function JSONDateWithTimezoneReplacer(this: any, key: string, value: unknown): unknown;
+export interface AlertErrorProps extends Omit<AlertProps, 'icon'> {
+    iconTooltip?: string;
+}
+export const AlertErrorDefaultProps: Partial<AlertErrorProps>;
+export function AlertError(props: AlertErrorProps): import("react/jsx-runtime").JSX.Element;
+export const AlertInfoDefaultProps: Partial<AlertProps>;
+export function AlertInfo(props: AlertProps): import("react/jsx-runtime").JSX.Element;
+export const AlertSuccessDefaultProps: Partial<AlertProps>;
+export function AlertSuccess(props: AlertProps): import("react/jsx-runtime").JSX.Element;
+export interface ColorConfigurationValue {
+    colorKey: DefaultMantineColor;
+    colorShade: any;
+}
+export interface ColorConfigurationProps {
+    onChange(color: ColorConfigurationValue): void;
+    value: ColorConfigurationValue;
+}
+export function ColorConfiguration({ onChange, value }: ColorConfigurationProps): import("react/jsx-runtime").JSX.Element;
+export interface LoginOptions {
+    client: MicroMClient;
+    onStatusCompleted: StatusCompletedHandler<MicroMToken>;
+    userLabel?: string;
+    userPlaceholder?: string;
+    passwordLabel?: string;
+    passwordPlaceholder?: string;
+    rememberLabel?: string;
+    forgotLabel?: string;
+    signInButtonLabel?: string;
+    loginErrorMessage?: string;
+    confirmRecoveryEmailTitle?: string;
+}
+export const LoginDefaultProps: Partial<LoginOptions>;
+export interface LoginValues {
+    user: string;
+    password: string;
+    server: string;
+    rememberme: boolean;
+}
+export function Login(props: LoginOptions): import("react/jsx-runtime").JSX.Element;
+export interface LoginModalProps {
+    client: MicroMClient;
+    title?: string;
+    onClose?: () => void;
+    onLoggedIn: (claims?: Partial<MicroMClientClaimTypes>) => void;
+    checkOnInit?: boolean;
+}
+export const LoginModalDefaultProps: Partial<LoginModalProps>;
+export function LoginModal(props: LoginModalProps): import("react/jsx-runtime").JSX.Element;
+/** Flags for determining the role of the column */
+export enum EntityColumnFlags {
+    /** This flag indicates that this column is NOT sent as parameter to any API endpoint */
+    None = 0,
+    /**Flag: get. This column will be sent as parameter for the GET API endpoint */
+    get = 1,
+    /**Flag: add. This column will be sent as parameter for the ADD API endpoint */
+    add = 2,
+    /**Flag: edit. This column will be sent as parameter for the EDIT API endpoint */
+    edit = 4,
+    /**Flag: delete. This column will be sent as parameter for the DELETE API endpoint */
+    delete = 8,
+    /**Flag: pk. This column is part of the PRIMARY KEY and will be sent as parameter for any API endpoint that requires a key */
+    pk = 16,
+    /**Flag: fk. This column is part of a FOREIGN KEY and will be sent as parameter for any API endpoint that requires a PARENT KEYS */
+    fk = 32,
+    /**Flag: autoNum. This column will have an incremental number assigned to it as result of calling the ADD API */
+    autoNum = 64,
+    /**Flag: nullable. This column accpets NULL values at the SQL table level */
+    nullable = 128,
+    /**Flag: nullable. This column is not part of the physical entity, it may be used as a calculated value or embedded value from other entity */
+    fake = 256
+}
+export interface EntityColumnOptions<T extends Value> {
+    name: string;
+    type: SQLType;
+    length?: number;
+    scale?: number;
+    value?: T;
+    defaultValue?: T;
+    flags: EntityColumnFlags;
+    prompt?: string;
+    placeholder?: string;
+    description?: string;
+    isArray?: boolean;
+    excludeInAutoForm?: boolean;
+    valueDescription?: string;
+}
+/** CommonFlags are pre assembled EntityColumnFlags to ease declaring columns */
+export const CommonFlags: {
+    /** PK = EntityColumnFlags.add | EntityColumnFlags.edit | EntityColumnFlags.delete | EntityColumnFlags.pk*/
+    PK: EntityColumnFlags;
+    /**PKAutonum = EntityColumnFlags.add | EntityColumnFlags.edit | EntityColumnFlags.delete | EntityColumnFlags.pk | EntityColumnFlags.autoNum*/
+    PKAutonum: EntityColumnFlags;
+    /**FK = EntityColumnFlags.add | EntityColumnFlags.edit | EntityColumnFlags.fk*/
+    FK: EntityColumnFlags;
+    /**Edit = EntityColumnFlags.add | EntityColumnFlags.edit*/
+    Edit: EntityColumnFlags;
+};
+export interface ColumnsFilter {
+    flags?: EntityColumnFlags;
+    ignoreDefaults?: boolean;
+    matchAllFlags?: boolean;
+    ignoreSystemColumns?: boolean;
+}
+export function checkAdmittedValue(col: EntityColumn<Value>, value: Value, throwException?: boolean): boolean;
+export class EntityColumn<T extends Value> {
+    name: string;
+    type: SQLType;
+    length: number;
+    scale: number;
+    flags: EntityColumnFlags;
+    prompt: string;
+    placeholder: string;
+    description: string;
+    isArray: boolean;
+    excludeInAutoForm: boolean;
+    constructor({ name, type, length, scale, value, defaultValue, flags, prompt, placeholder, description, isArray, excludeInAutoForm, valueDescription }: EntityColumnOptions<T>);
+    get value(): T;
+    set value(newValue: T);
+    get defaultValue(): T;
+    set defaultValue(newValue: T);
+    get valueDescription(): string | undefined;
+    set valueDescription(newValue: string | undefined);
+    hasFlag(flagOption: EntityColumnFlags): boolean;
+    hasAnyFlag(combinedFlags: EntityColumnFlags): boolean;
+    static clone(source: EntityColumn<Value>): EntityColumn<string | number | boolean | Date | string[] | null>;
+}
+export type ColumnsObject = Record<string, EntityColumn<Value>>;
+export const SYSTEM_COLUMNS_NAMES: string[];
+export interface IDefaultColumns extends ColumnsObject {
+    dt_inserttime: EntityColumn<Date>;
+    dt_lu: EntityColumn<Date>;
+    vc_webinsuser: EntityColumn<string>;
+    vc_webluuser: EntityColumn<string>;
+    vc_insuser: EntityColumn<string>;
+    vc_luuser: EntityColumn<string>;
+}
+export const DefaultColumnsNames: string[];
+export const DefaultColumns: () => IDefaultColumns;
+export function hasValue(value: Value): boolean;
+export function convertValueFromString(col: EntityColumn<Value>, value: string): Value;
+export function isIn<T>(value: T, ...params: T[]): boolean;
+export function isPromise<T>(obj: unknown): obj is Promise<T>;
+export function createKeysSet<T>(): Set<keyof T>;
+export function createKeysArray<T>(): Array<keyof T>;
+export function areArraysContentsEqual(a: string[] | undefined, b: string[] | undefined): boolean;
+export function arrayToObject<T, TValue>(values: T[], onGetKey: (item: T) => string, onGetValue?: (item: T) => TValue): Record<string, TValue>;
+export function cloneColumns(source_columns: Record<string, EntityColumn<Value>>): Record<string, EntityColumn<Value>>;
+export function areValuesEqual(values1: ValuesObject, values2: ValuesObject): boolean;
+export function areValuesObjectsEqual(objA: ValuesObject | undefined, objB: ValuesObject | undefined): boolean;
+/**
+ * Get a filtered columns array (without duplicates)
+ */
+export function getColumns(columns: ColumnsObject, filter: ColumnsFilter | null): EntityColumn<Value>[];
+export function filterColumns(columns: EntityColumn<Value>[], filter: ColumnsFilter | null): EntityColumn<Value>[];
+/**
+ * Create a ValuesDictionary object containing the matched columns names and values.
+ */
+export function getValuesObject(columns: ColumnsObject, filters: ColumnsFilter | null): Record<string, Value>;
+/**
+ * Create an array of values containing the matched columns values only.
+ */
+export function getValuesArray(columns: ColumnsObject, filters: ColumnsFilter | null): Value[];
+/**
+ * Filter a columns object
+ */
+export function getColumnsObject(columns: ColumnsObject, filters: ColumnsFilter | null): Record<string, EntityColumn<Value>>;
+/**
+ * Convert a columns array to columnsObject
+ */
+export function toColumnsObject(columns: EntityColumn<Value>[]): Record<string, EntityColumn<Value>>;
+/**
+ * Create an array of strings containing the matched columns names only.
+ */
+export function getColumnsNamesArray(columns: ColumnsObject, filters: ColumnsFilter | null): string[];
+/**
+ * Create a dictionary-like object containing the column names and values.
+ */
+export function getValues(columns: ColumnsObject, filter: ColumnsFilter | null): Record<string, Value>;
+export function setSourceValue(columnName: string, sourceValue: Value | EntityColumn<Value>, columns: Partial<Record<string, EntityColumn<Value>>>, ignoreInexistentColumns: boolean, ignoreEmptySourceValues: boolean, convertStringArray: boolean): void;
+/**
+ * Sets matched columns values from any supported source type.
+ * By default, all columns are matched and throws error if column is not found.
+ */
+export function setValues(columns: ColumnsObject, sourceValues?: ValuesObject | ColumnsObject | EntityColumn<Value>[], filters?: ColumnsFilter | null, ignoreInexistentColumns?: boolean, ignoreEmptySourceValues?: boolean, convertStringArray?: boolean): void;
+/**
+ * Clears the matched columns values.
+ */
+export function clearValues(columns: ColumnsObject, useColumnDefaultValue?: boolean, filters?: ColumnsFilter | null): void;
+/**
+ * Sets the matched columns values using the entity parent keys as source.
+ * By default, only columns with PKFlag or FKFlag set are affected and if the parent key value is empty, then the column is not affected.
+ */
+export function fillParentKeys(columns: ColumnsObject, parentKeys: ColumnsObject, ignoreEmptyParentKeys?: boolean, filters?: ColumnsFilter | null): void;
+export function namesOf<T>(): { [P in keyof T]: P; };
+export function copyValuesObject(obj: ValuesObject): ValuesObject;
+export type ValidationRule = (value: unknown, values?: Record<string, unknown>) => string | number | true | ReactElement<any, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null;
+export type ValidatorFunction = (...args: any[]) => ValidationRule;
+export const isURL: ValidatorFunction;
+export const combineValidators: (Container?: React.ComponentType<{
+    children: ReactNode;
+}>, ...validators: ValidationRule[]) => ValidationRule;
+export const isValidCUIT: ValidatorFunction;
+export const isValidEmail: ValidatorFunction;
+export const isPhone: ValidatorFunction;
+export const CustomValidator: ValidatorFunction;
+export const CommonValidators: {
+    url: ValidatorFunction;
+    phone: ValidatorFunction;
+    cuit: ValidatorFunction;
+    email: ValidatorFunction;
+    length: typeof hasLength;
+    required: typeof isNotEmpty;
+    regex: typeof matches;
+    range: typeof isInRange;
+    field: ValidatorFunction;
+    custom: ValidatorFunction;
+};
+export type CommonValidatorsType = Record<keyof typeof CommonValidators, ValidatorFunction>;
+export type ValidatorConfigurationParms = {
+    message?: ReactNode;
+    data?: any;
+};
+export type ValidatorConfiguration = Partial<Record<keyof typeof CommonValidators, ValidatorConfigurationParms>>;
+export function getMantineInitialDirty(columns: ColumnsObject, exclude_system_columns: boolean): Record<string, boolean>;
+export function getMantineValuesObject(formValues: ValuesObject, columns: ColumnsObject, exclude_system_columns: boolean): ValuesObject;
+export function getMantineInitialValuesObject(columns: ColumnsObject, columnNames?: string[]): ValuesObject;
+export interface UseEntityFormOptions extends FormOptions<Entity<EntityDefinition>> {
+    validateInputOnBlur?: boolean;
+    validateInputOnChange?: boolean | LooseKeys<ValuesObject>[];
+    getDataOnInit: boolean;
+    forceDirty?: boolean;
+    initialShowDescriptionInFields?: boolean;
+    saveAndGetOverride?: (get_data_if_saved: boolean, override_values?: ValuesObject) => Promise<OperationStatus<DBStatusResult>>;
+    noSaveOnSubmit?: boolean;
+    bindedColumnNames?: string[];
+    saveAndGetOnSubmit?: boolean;
+    cancelGetOnUnmount?: boolean;
+    cancelSaveOnUnmount?: boolean;
+}
+export type GetColumnInputPropsReturnType = {
+    value: any;
+    onChange: any;
+    checked?: any;
+    error?: any;
+    onFocus?: any;
+    onBlur?: any;
+};
+export interface UseEntityFormReturnType {
+    form: UseFormReturnType<ValuesObject>;
+    status: OperationStatus<DBStatusResult | ValuesObject>;
+    formMode: FormMode;
+    handleCancel: () => Promise<void> | void;
+    handleSubmit: (event?: React.FormEvent<HTMLFormElement>) => Promise<void>;
+    performGetData: () => Promise<boolean>;
+    saveAndGet: (get_data_if_saved: boolean, override_values?: ValuesObject) => Promise<OperationStatus<DBStatusResult>>;
+    configureField: (column: EntityColumn<Value>, validation?: ValidationRule) => void;
+    removeValidation: (column: EntityColumn<Value>) => void;
+    notifyValidationErrorState: useStateReturnType<boolean>;
+    showDescriptionState: useStateReturnType<boolean>;
+    entity: Entity<EntityDefinition>;
+    asyncErrors: Record<string, string>;
+    setAsyncError: (column_name: string, error: string) => void;
+    clearAsyncError: (column_name: string) => void;
+    clearAllAsyncErrors: () => void;
+    isFormValid: () => boolean;
+    isFormFieldValid: (column_name: string) => boolean;
+}
+export const UseEntityFormDefaultProps: Partial<UseEntityFormOptions>;
+export function useEntityForm(props: UseEntityFormOptions): UseEntityFormReturnType;
+export interface EntityFormProps extends PropsWithChildren {
+    showOK?: boolean;
+    showCancel?: boolean;
+    showFormValidationNotification?: boolean;
+    showLoadingProgress?: boolean;
+    showErrors?: boolean;
+    OKText?: ReactNode;
+    CancelText?: ReactNode;
+    CloseText?: ReactNode;
+    formAPI: UseEntityFormReturnType;
+    invalidFieldsLabel?: string;
+    showHelpButton?: boolean;
+    initialShowDescriptionInFields?: boolean;
+    preventEnterSubmission?: boolean;
+    buttons?: ReactNode;
+    saveAndGetOnSubmit?: boolean;
+    isDirtyColor?: DefaultMantineColor;
+    cancelButtonVariant?: Variants<'filled' | 'outline' | 'light' | 'white' | 'default' | 'subtle' | 'gradient'>;
+    okButtonVariant?: Variants<'filled' | 'outline' | 'light' | 'white' | 'default' | 'subtle' | 'gradient'>;
+}
+export const EntityFormDefaultProps: Partial<EntityFormProps>;
+export function EntityForm(props: EntityFormProps): import("react/jsx-runtime").JSX.Element;
+export type UseFieldConfigurationProps = {
+    entityForm: UseEntityFormReturnType;
+    column: EntityColumn<Value>;
+    required?: boolean;
+    requiredMessage?: ReactNode;
+    validate?: ValidatorConfiguration;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    readOnly?: boolean;
+};
+export const UseFieldConfigurationDefaultProps: Partial<UseFieldConfigurationProps>;
+export const useFieldConfiguration: (props: UseFieldConfigurationProps) => void;
+export interface EntityFormPageProps extends Omit<FormOptions<Entity<any>>, 'entity'> {
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+    client: MicroMClient;
+    defaultLoadingComponent?: ReactNode;
+}
+export const EntityFormPagePropsDefaultProps: Partial<EntityFormPageProps>;
+export function EntityFormPage(props: EntityFormPageProps): import("react/jsx-runtime").JSX.Element;
+export interface StepperFormStep {
+    name: string;
+    label: string;
+    description?: string;
+    validateFields?: string[];
+    content: ReactNode;
+    nextStepLabel?: string;
+    nextStepValidLabel?: string;
+    nextStepValidation?: () => boolean | Promise<boolean>;
+    icon?: ReactNode;
+}
+export interface StepperFormProps extends EntityFormProps {
+    steps: StepperFormStep[];
+    onNextStep?: (step: StepperFormStep) => boolean | Promise<boolean>;
+    onPrevStep?: (step: StepperFormStep) => boolean | Promise<boolean>;
+    initialStep: number;
+    nextStepLabel?: string;
+    prevStepLabel?: string;
+    allowStepClickForward?: boolean;
+    completedContent?: ReactNode;
+    hideNextAndBackWhenCompleted?: boolean;
+    onCompleted?: () => void;
+    stepperProps?: Omit<Partial<StepperProps>, 'children' | 'active'>;
+}
+export const StepperFormDefaultProps: Partial<StepperFormProps>;
+export function StepperForm(props: StepperFormProps): import("react/jsx-runtime").JSX.Element;
+export function getWindowLocationQueryStringAsObject(): Record<string, string>;
+export function buildURLQueryString(params: Record<string, Value>): string;
+export function getWindowLocationQueryStringAsValueObject(columns: ColumnsObject): ValuesObject;
+export interface EntityFormModalProps {
+    client: MicroMClient;
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+    initialFormMode?: FormMode;
+    getDataOnInit?: boolean;
+    openState: boolean;
+    setOpenState: (open: boolean) => void;
+    onModalClosed?: () => void;
+    onModalSaved?: (status: OperationStatus<DBStatusResult | null>) => Promise<void>;
+    modalFormSize?: MicroMModalSize;
+}
+export const EntityFormModalDefaultProps: Partial<EntityFormModalProps>;
+export function EntityFormModal(props: EntityFormModalProps): null;
+export type FormMode = 'add' | 'edit' | 'view';
+export interface KeyStringIndexer {
+    [key: string]: any;
+}
+export interface NumberIndexer {
+    [key: number]: any;
+}
+export interface FormOptions<T extends Entity<EntityDefinition>> extends Omit<EntityFormProps, 'formAPI' | 'children'> {
+    entity: T;
+    initialFormMode: FormMode;
+    getDataOnInit?: boolean;
+    onSaved?: (status: OperationStatus<DBStatusResult>) => void;
+    onCancel?: () => void;
+}
+export type useStateReturnType<T> = [T, React.Dispatch<React.SetStateAction<T>>];
+export type ActionIconVariant = 'transparent' | 'subtle' | 'default' | 'outline' | 'filled' | 'light';
+export type ButtonVariant = 'gradient' | 'subtle' | 'default' | 'outline' | 'filled' | 'light' | 'white';
+export type latLng = {
+    lat: number;
+    lng: number;
+};
+export interface EntityError extends Error {
+    Errors: DBStatus[];
+}
+export interface EntityProc {
+    name: string;
+    parms?: Record<string, Value>;
+}
+export interface EntityClientActionOnClickProps {
+    entity: Entity<any>;
+    modal?: ModalContextType;
+    selectedKeys?: ValuesObject[];
+    element?: HTMLElement;
+    onClose?: (result?: boolean) => Promise<boolean>;
+}
+export interface EntityClientAction {
+    name: string;
+    title: ReactNode;
+    label: ReactNode;
+    icon?: ReactNode;
+    refreshOnClose?: boolean;
+    dontRequireSelection?: boolean;
+    minSelectedRecords?: number;
+    maxSelectedRecords?: number;
+    views?: string[];
+    showActionInViewMode?: boolean;
+    onClick: (props: EntityClientActionOnClickProps) => Promise<boolean>;
+}
+export interface ViewMapping {
+    keyIndex: number;
+    descriptionIndex: number;
+}
+export interface EntityConstructor {
+    (client: MicroMClient, parentKeys?: ValuesObject): Entity<EntityDefinition>;
+}
+export interface EntityLookup {
+    name: string;
+    entityConstructor: EntityConstructor;
+    view?: string;
+    proc?: string;
+    bindingColumnKey?: string;
+    viewMapping?: ViewMapping;
+}
+export interface EntityView {
+    name: string;
+    keyMappings: Record<string, number>;
+    Card?: Promise<ComponentType<EntityCardProps<ValuesObject>>> | null;
+    FiltersEntity?: EntityConstructor;
+    gridColumnsOverrides?: (theme: MantineTheme) => GridColumnsOverrides;
+    mapMarkerRenderer?: DataMapProps['markerRenderer'];
+    mapGroupMarkerRenderer?: DataMapProps['groupMarkerRenderer'];
+    mapInfoWindowRenderer?: DataMapProps['InfoWindowRenderer'];
+    mapSelectRecordsRenderer?: DataMapProps['selectRecordsRenderer'];
+}
+export class EntityDefinition {
+    name: string;
+    columns: ColumnsObject;
+    procs: Record<string, EntityProc>;
+    views: Record<string, EntityView>;
+    lookups: Record<string, EntityLookup>;
+    serverActions: Record<string, EntityServerAction>;
+    clientActions: Record<string, EntityClientAction>;
+    importColumns: string[] | null;
+    standardView(): string | null;
+    constructor(name: string);
+    addCol<T extends Value>({ name, type, length, scale, value, defaultValue, flags, prompt }: EntityColumnOptions<T>): EntityColumn<T>;
+    addView(view: EntityView): EntityView;
+    addProc(proc: EntityProc): EntityProc;
+    addLookup(lookup: EntityLookup): EntityLookup;
+    addServerAction(action: EntityServerAction): EntityServerAction;
+    addClientAction(action: EntityClientAction): EntityClientAction;
+    static clone(entity_def: EntityDefinition): EntityDefinition;
+}
+export interface EntityServerAction {
+    name: string;
+    valuesMapper?: (values: ValuesObject) => EntityDefinition;
+    columnsMapper?: (columns: ColumnsObject) => ValuesObject;
+}
+export class EntityAPI {
+    #private;
+    client: MicroMClient;
+    constructor(client: MicroMClient, name: string, columns: ColumnsObject);
+    /**
+     * Get the data for the current row and fill the columns values with it.
+     */
+    getData(abort_signal?: AbortSignal | null): Promise<boolean>;
+    /**
+     * Add the data for the current row and fill the key columns values with the returned auto-numeric (if any).
+     */
+    addData(abort_signal?: AbortSignal | null, recordsSelection?: ValuesObject[], ignoreRecordExists?: boolean): Promise<DBStatusResult>;
+    /**
+     * Edits the data for the current row.
+     */
+    editData(abort_signal?: AbortSignal | null, recordsSelection?: ValuesObject[]): Promise<DBStatusResult>;
+    /**
+     * Deletes the data for the current row.
+     */
+    deleteData(recordsSelection?: ValuesObject[], abort_signal?: AbortSignal | null, parentKeys?: ValuesObject | null): Promise<DBStatusResult>;
+    /**
+     * Lookup the description for an entity.
+     */
+    lookupData(abort_signal?: AbortSignal | null): Promise<string>;
+    /**
+     * Import data
+     */
+    importData(abort_signal: (AbortSignal | null) | undefined, import_procname: (string | null) | undefined, parentKeys: (ValuesObject | null) | undefined, fileprocess_id: string): Promise<ImpDataResult>;
+    executeView(view: EntityView, view_parms?: ValuesObject, limit?: string | null, search?: string[] | null, abort_signal?: AbortSignal | null): Promise<DataResult[]>;
+    executeProc(proc: EntityProc, proc_parms?: ValuesObject, abort_signal?: AbortSignal | null, recordsSelection?: ValuesObject[]): Promise<DataResult[]>;
+    executeProcess(proc: EntityProc, proc_parms?: ValuesObject, abort_signal?: AbortSignal | null, recordsSelection?: ValuesObject[]): Promise<DBStatusResult>;
+    executeServerAction<TReturn extends Record<string, unknown>>(action: EntityServerAction, action_parms?: ValuesObject, abort_signal?: AbortSignal | null): Promise<TReturn>;
+}
+export type EntityFormComponentPromise = Promise<ComponentType<FormOptions<Entity<any>>>>;
+export class Entity<T extends EntityDefinition> {
+    #private;
+    get name(): string;
+    get def(): T;
+    parentKeys: ValuesObject;
+    API: EntityAPI;
+    Form: EntityFormComponentPromise | "AutoForm" | "AutoFiltersForm" | null;
+    Title: string;
+    HelpText?: string;
+    Icon?: ComponentType<IconProps>;
+    constructor(client: MicroMClient, def: T, parentKeys?: ValuesObject);
+    static clone(entity: Entity<EntityDefinition>): Entity<EntityDefinition>;
+}
+export type MappingBehavior = 'lax' | 'enforceObject' | 'enforceDataResult' | 'exactMatch';
+export function toCamelCase(str: string): string;
+/** function to convert a record array to a values object */
+export function convertRecordToValuesObject(record: ValuesRecord, headers: string[], typeInfo: SQLType[], formatToString?: (value: Value, sqlType: SQLType) => string): ValuesObject;
+export function convertRecordsToArrayOfValuesObject(dataResult: DataResult, nameTransformFunction?: ((name: string) => string) | null, formatToString?: (value: Value) => string): ValuesObject[];
+export function mapRecordToType<T extends ValuesObject>(record: ValuesRecord, headers: string[], enforceObjectKeys: Set<string>, mapping_behavior: MappingBehavior, map_properties?: Record<string, keyof T> | null, skipUndefinedOrNull?: boolean): T;
+export function mapDataResultToType<T extends ValuesObject>(dataResult: DataResult, mapping_behavior: MappingBehavior, nameTransformFunction?: ((name: string) => string) | null, map_properties?: Record<string, keyof T> | null, skipUndefinedOrNull?: boolean): T[];
+export function exportToCSV(viewResult: DataResult, notExportableColumns?: number[]): void;
+export function extractArrayFromSelectedRecords<T>(selectedKeys: ValuesObject[], property: keyof ValuesObject): T[];
+export function isInstanceOfEntityColumn<T extends Value>(obj: unknown): obj is EntityColumn<T>;
+export function isViewMapping(obj: unknown): obj is ViewMapping;
+export function isEntityLookup(obj: unknown): obj is EntityLookup;
+export function getRequiredColumns(entity?: Entity<EntityDefinition>): string[];
+export interface ColumnMapRecord {
+    columnName: string;
+    propertyName: string;
+}
+export type ColumnMap = ColumnMapRecord[];
+export interface ColumnsMapRecord<T extends Partial<ColumnsObject>, V> {
+    columnName: keyof T;
+    propertyName: keyof V;
+}
+export type ColumnsMap<T extends Partial<ColumnsObject>, V> = ColumnsMapRecord<T, V>[];
+/**
+ * Returns a dictionary of column names mapped to property names.
+ * @param map
+ * @returns
+ */
+export function getDictionaryByColumnName<T extends Partial<ColumnsObject>, V>(map: ColumnsMap<T, V>): Record<keyof T, keyof V>;
+/**
+ * Returns a dictionary of property names mapped to column names.
+ * @param map
+ * @returns
+ */
+export function getDictionaryByPropertyName<V, T extends Partial<ColumnsObject>>(map: ColumnsMap<T, V>): Record<keyof V, keyof T>;
+export function mapToRecordSelection<T extends Partial<ColumnsObject>, V>(values: V[], propertiesMapDictionary: Record<keyof V, keyof T>): ValuesObject[];
+export class ColumnsMapper<T extends Entity<EntityDefinition>, V extends ValuesObject> {
+    #private;
+    constructor(entity: T, values: V, records: ColumnMapRecord[]);
+    columnsDictionary: Record<string, string>;
+    valuesDictionary: Record<string, string>;
+    mapValuesToColumns(columns: ColumnsObject, values: V, ignoreInvalidMappings?: boolean, ignoreInexistentValues?: boolean): void;
+    mapColumnsToValues(columns: ColumnsObject, ignoreInvalidMappings?: boolean, ignoreInexistentValues?: boolean): Partial<V>;
+}
+export interface useTextTransformProps {
+    entityForm: UseEntityFormReturnType;
+    column: EntityColumn<Value>;
+    transform?: "uppercase" | "lowercase" | "capitalize" | "titlecase";
+    autoTrim?: boolean;
+}
+export function useTextTransform(props: useTextTransformProps): (text: string) => void;
+type TextAreaFieldAllowedValidators = 'regex' | 'length' | 'field' | 'required';
+export type TextAreaFieldValidatorConfiguration = Partial<Record<TextAreaFieldAllowedValidators, ValidatorConfigurationParms>>;
+export interface TextAreaFieldProps extends TextareaProps, Omit<useTextTransformProps, 'entityForm' | 'column' | 'onBlur' | 'mantineOnBlur'> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: TextAreaFieldValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autofocus?: boolean;
+}
+export const TextAreaField: import("react").ForwardRefExoticComponent<TextAreaFieldProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export interface TextFieldProps extends TextInputProps, Omit<useTextTransformProps, 'entityForm' | 'column'> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+}
+export const TextField: import("react").ForwardRefExoticComponent<TextFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface AutoFormFieldsProps<T extends Entity<EntityDefinition>> {
+    entity: T;
+    entityForm: UseEntityFormReturnType;
+}
+export function AutoFormFields(props: AutoFormFieldsProps<Entity<EntityDefinition>>): (import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined)[];
+export function AutoForm(props: FormOptions<Entity<EntityDefinition>>): import("react/jsx-runtime").JSX.Element;
+export interface ModalFormOptions {
+    entity: Entity<EntityDefinition>;
+    onSaved: (entity: Entity<EntityDefinition>) => void;
+    onCancel: (entity: Entity<EntityDefinition>) => void;
+}
+export function ModalForm({ entity, onSaved, onCancel }: ModalFormOptions): import("react/jsx-runtime").JSX.Element;
+export type MicroMModalSize = MantineNumberSize | 'fullscreen';
+export type MicroMModalSettings = Partial<Omit<ModalSettings, 'size'>> & {
+    size?: MicroMModalSize;
+};
+export interface ModalOpenProps {
+    content: ReactNode | Promise<ReactNode>;
+    modalProps: MicroMModalSettings;
+    onClosed?: () => void;
+    focusOnClosed?: HTMLElement;
+}
+export interface ModalContextType {
+    open: (props: ModalOpenProps, onClosed?: () => void) => Promise<void>;
+    close: () => Promise<void>;
+}
+export interface ModalType {
+    originalContent: ReactNode | Promise<ReactNode>;
+    resolvedContent?: ReactNode;
+    props: ModalSettings;
+    id: string;
+    opened: boolean;
+    onClosed?: () => void;
+    focusOnClosed?: HTMLElement;
+}
+export interface ModalsManagerProps extends PropsWithChildren {
+    modalProps: MicroMModalSettings;
+    /** This delay in milliseconds will be used to wait for the modal to be closed and fire the onClosed() event */
+    animationDuration: number;
+}
+export const ModalsManager: ({ modalProps, animationDuration, children }: ModalsManagerProps) => import("react/jsx-runtime").JSX.Element;
+export const useModal: () => ModalContextType;
+export interface SearchInputProps extends TextInputProps {
+    onSearchClick: React.MouseEventHandler;
+    size: string;
+    iconsSize: string;
+    value: string;
+    onChange: React.ChangeEventHandler<HTMLInputElement>;
+    placeholder?: string;
+    autoFocus?: boolean;
+    iconVariant?: ActionIconVariant;
+    [x: string]: any;
+}
+export const SearchInputDefaultProps: Partial<SearchInputProps>;
+export function SearchInput(props: SearchInputProps): import("react/jsx-runtime").JSX.Element;
+export interface ToggleActionIconOptions {
+    hidden: boolean;
+    size: string;
+    onColor: MantineColor;
+    offColor: MantineColor;
+    onVariant?: ActionIconVariant;
+    offVariant?: ActionIconVariant;
+    onIcon: ReactNode;
+    offIcon: ReactNode;
+    initialStatus?: 'on' | 'off';
+    onClick?: () => void;
+    radius?: MantineNumberSize;
+    title?: string;
+}
+export const ToggleActionIcon: import("react").ForwardRefExoticComponent<ToggleActionIconOptions & import("react").RefAttributes<HTMLButtonElement>>;
+export function useExecuteView(entity?: Entity<EntityDefinition>, values?: ValuesObject, viewName?: string, search?: string[] | undefined, limit?: string | null, refresh?: boolean, filters?: ValuesObject): OperationStatus<DataResult[]>;
+export function useDebugProps<T>(propsObject: T, dependencies: any[], componentName: string): void;
+export function useEnterAsTab<T extends HTMLElement>(): import("react").MutableRefObject<T | null>;
+export interface useLoginType {
+    login: () => void;
+}
+export interface useLoginOptions {
+    client: MicroMClient;
+    modalProps?: ModalSettings;
+    onClose?: () => void;
+    title?: string;
+}
+export const UseLoginDefaultProps: Partial<useLoginOptions>;
+export function useLogin(props: useLoginOptions): () => Promise<void>;
+type PasswordFieldAllowedValidators = 'regex' | 'length' | 'field' | 'required';
+export type PasswordFieldValidatorConfiguration = Partial<Record<PasswordFieldAllowedValidators, ValidatorConfigurationParms>>;
+export interface PasswordFieldProps extends PasswordInputProps {
+    column: EntityColumn<string>;
+    entityForm: UseEntityFormReturnType;
+    loading?: boolean;
+    disableOnLoading?: boolean;
+    validate?: PasswordFieldValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export function PasswordField(props: PasswordFieldProps): import("react/jsx-runtime").JSX.Element;
+export type useExecuteActionReturnType<TReturn extends EntityDefinition | ValuesObject> = {
+    status: OperationStatus<TReturn>;
+    execute: (values?: ValuesObject) => Promise<OperationStatus<TReturn> | undefined>;
+};
+export function useExecuteServerAction<T extends EntityDefinition, TReturn extends EntityDefinition | ValuesObject>(entity: Entity<T>, actionName: string): useExecuteActionReturnType<TReturn>;
+export const NotifySuccessDefaultProps: Partial<NotificationProps>;
+export function NotifySuccess(props: NotificationProps): import("react/jsx-runtime").JSX.Element;
+export function NotifyError(props: NotificationProps): import("react/jsx-runtime").JSX.Element;
+export const NotifyInfoDefaultProps: Partial<NotificationProps>;
+export function NotifyInfo(props: NotificationProps): import("react/jsx-runtime").JSX.Element;
+export interface NotifyBitFieldProps extends NotificationProps {
+    column: EntityColumn<boolean>;
+    trueIcon?: ReactNode;
+    falseIcon?: ReactNode;
+    trueMessage: ReactNode;
+    falseMessage: ReactNode;
+    trueColor?: MantineColor;
+    falseColor?: MantineColor;
+}
+export const NotifyBitFieldDefaultProps: Partial<NotifyBitFieldProps>;
+export function NotifyBitField(props: NotifyBitFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface CheckboxFieldProps extends CheckboxProps {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    loading?: boolean;
+    disableOnLoading?: boolean;
+    requiredMessage?: ReactNode;
+}
+export function CheckboxField(props: CheckboxFieldProps): import("react/jsx-runtime").JSX.Element;
+export function FakeProgressBar(props: ProgressProps): import("react/jsx-runtime").JSX.Element;
+export interface UseOperationStatusCallback<T> {
+    callback: (...args: any[]) => Promise<T>;
+    operation: DataOperationType;
+    deps: React.DependencyList;
+}
+export type UseOperationStatusCallbackReturnType<T> = {
+    operationCallback: (...args: any[]) => Promise<OperationStatus<T>>;
+    status: OperationStatus<T>;
+};
+export function useOperationStatusCallback<T>(props: UseOperationStatusCallback<T>): UseOperationStatusCallbackReturnType<T>;
+export interface ConfirmPanelProps {
+    content: ReactNode;
+    loadingContent?: ReactNode;
+    operation: DataOperationType;
+    onOK: () => Promise<unknown>;
+    onCancel: () => Promise<void> | void;
+    cancelButtonText?: string;
+    okButtonText?: string;
+    okButtonProps?: ButtonProps;
+    cancelButtonProps?: ButtonProps;
+    runOnOpen?: boolean;
+}
+export const ConfirmAndExecutePanelDefaultProps: Partial<ConfirmPanelProps>;
+export function ConfirmAndExecutePanel(props: ConfirmPanelProps): import("react/jsx-runtime").JSX.Element;
+export interface EmailFieldProps extends Omit<TextFieldProps, 'validate'> {
+    invalidMessage?: string;
+}
+export const EmailFieldDefaultProps: Partial<EmailFieldProps>;
+export function EmailField(props: EmailFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface UrlFieldProps extends Omit<TextFieldProps, 'validate'> {
+    invalidMessage?: string;
+}
+export const UrlFieldDefaultProps: Partial<UrlFieldProps>;
+export function UrlField(props: UrlFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface UseDynamicContentProps {
+    contentState: ReturnType<typeof useState<ReactNode>>;
+    dynamicContent: Promise<ReactNode>;
+    loading?: ReactNode;
+}
+export function useDynamicContent(props: UseDynamicContentProps): void;
+export interface CopyToClipboardProps extends ActionIconProps {
+    valueToCopy: unknown;
+    timeout?: number;
+    copiedColor?: MantineColor;
+    iconSize?: string | number;
+}
+export function CopyToClipboard(props: CopyToClipboardProps): import("react/jsx-runtime").JSX.Element;
+export interface CodeBlockProps extends Omit<PrismProps, 'children'> {
+    codeText: string;
+}
+export function CodeBlock(props: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export interface DateInputFieldProps extends DateInputProps {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+}
+export const DateInputFieldDefaultProps: Partial<DateInputFieldProps>;
+export const DateInputField: import("react").ForwardRefExoticComponent<DateInputFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface NumberFieldProps extends NumberInputProps {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    loading?: boolean;
+    disableOnLoading?: boolean;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+}
+export const NumberField: import("react").ForwardRefExoticComponent<NumberFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface UseHierarchyKeysProps {
+    formAPI: UseEntityFormReturnType;
+    hierarchy: string[];
+    mappedHierarchy?: string[];
+}
+export function useHierarchyKeys(props: UseHierarchyKeysProps): Record<string, Value>[];
+export interface PhoneFieldProps extends Omit<TextFieldProps, 'validate'> {
+    invalidMessage?: string;
+    showCallIcon?: boolean;
+    showWhatsappIcon?: boolean;
+}
+export const PhoneFieldDefaultProps: Partial<PhoneFieldProps>;
+export function PhoneField(props: PhoneFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface CUITFieldProps extends TextFieldProps {
+    invalidMessage?: string;
+}
+export const CUITFieldDefaultProps: Partial<CUITFieldProps>;
+export function CUITField(props: CUITFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface UseParentKeysProps {
+    formAPI: UseEntityFormReturnType;
+    columnNames: string[];
+    entity: Entity<EntityDefinition>;
+}
+export function useParentKeys(props: UseParentKeysProps): ValuesObject;
+export interface TimeFieldProps extends Omit<TimeInputProps, 'validate'> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: React.ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+    showTimePicker?: boolean;
+}
+export const TimeFieldDefaultProps: Partial<TimeFieldProps>;
+interface TimeFieldRef {
+    showPicker: () => void;
+}
+export const TimeField: import("react").ForwardRefExoticComponent<TimeFieldProps & import("react").RefAttributes<TimeFieldRef>>;
+export function getInitials(input: string): string;
+export interface useIsLoggedInProps {
+    client: MicroMClient;
+    useLocalLoggedInCheck?: boolean;
+}
+export type useIsLoggedInReturnType = {
+    isLoggedIn: boolean | undefined;
+    setIsLoggedIn: Dispatch<SetStateAction<boolean | undefined>>;
+    checkIsLoggedIn: () => Promise<void>;
+    loggedInInfo: Partial<MicroMClientClaimTypes>;
+};
+export function useIsLoggedIn({ client, useLocalLoggedInCheck }: useIsLoggedInProps): useIsLoggedInReturnType;
+export const usePreventEnterSubmission: () => (event: KeyboardEvent) => void;
+export function formatDate(value: Value, locale?: string, dateOptions?: Intl.DateTimeFormatOptions): string;
+export function formatTime(value: Value, locale?: string, dateOptions?: Intl.DateTimeFormatOptions): string;
+export function formatNumber(value: Value, locale?: string): string;
+export function convertDateToNative(value: string): Date;
+export function formatSQLValue(value: Value, sqlType: SQLType, locale?: string): string;
+export function convertToNativeType(value: Value, sqlType: SQLType): Value;
+export interface UseLocaleFormatProps {
+    initialLocale?: string;
+}
+export const UseLocaleFormatDefaultProps: UseLocaleFormatProps;
+export function useLocaleFormat(props: UseLocaleFormatProps): {
+    locale: string | undefined;
+    setLocale: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+    formatValue: (value: Value, sqlType: SQLType) => string;
+    getNativeType: (value: Value, sqlType: SQLType) => Value;
+    formatColumnValue: (col: EntityColumn<Value>) => string;
+};
+export const UseImportDataDefaultProps: {
+    noFileProcessLabel: string;
+    errorImportingDataLabel: string;
+};
+export class CategoriesDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_category_id: EntityColumn<string>;
+        vc_description: EntityColumn<string>;
+    };
+    views: {
+        cat_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_category_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class CategoriesValuesDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_category_id: EntityColumn<string>;
+        c_categoryvalue_id: EntityColumn<string>;
+        vc_description: EntityColumn<string>;
+    };
+    views: {
+        cav_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_categoryvalue_id: number;
+            };
+        };
+    };
+    lookups: {
+        Categories: {
+            name: string;
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => Categories;
+        };
+    };
+    constructor();
+}
+export class CategoriesValues extends Entity<CategoriesValuesDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export const CategoriesFormDefaultProps: Partial<FormOptions<Categories>>;
+export function CategoriesForm(props: FormOptions<Categories>): import("react/jsx-runtime").JSX.Element;
+export class Categories extends Entity<CategoriesDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class catAuthenticationTypes extends Entity<CategoriesValuesDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class catUserTypes extends Entity<CategoriesValuesDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class MicromUsersGroupsDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_user_group_id: EntityColumn<string>;
+        vc_user_group_name: EntityColumn<string>;
+        vc_group_members: EntityColumn<string[]>;
+    };
+    views: {
+        mug_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_user_group_id: number;
+            };
+        };
+    };
+    lookups: {
+        MicromUsers: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsers;
+        };
+    };
+    constructor();
+}
+export const MicromUsersGroupsMenusDisableMenusLabels: {
+    denyAccessToSelectedMenuItems: string;
+    buttonLabel: string;
+    title: string;
+    areYouSure: string;
+};
+export const ACTDisableMenus: EntityClientAction;
+export const MicromUsersGroupsMenusEnableMenusLabels: {
+    allowAccessToSelectedMenuItems: string;
+    buttonLabel: string;
+    title: string;
+    areYouSure: string;
+};
+export const ACTEnableMenus: EntityClientAction;
+export interface MicromUsersGroupsMenusColumnsOverridesLabels {
+    granted: string;
+    denied: string;
+}
+export const MicromUsersGroupsMenusColumnsOverridesLabelsDefaultProps: Partial<MicromUsersGroupsMenusColumnsOverridesLabels>;
+export function MicromUsersGroupsMenusColumnsOverrides(theme: MantineTheme): {
+    4: {
+        render: (value: unknown) => import("react/jsx-runtime").JSX.Element;
+    };
+};
+export class MicromUsersGroupsMenusDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_user_group_id: EntityColumn<string>;
+        c_menu_id: EntityColumn<string>;
+        c_menu_item_id: EntityColumn<string>;
+    };
+    views: Record<string, EntityView>;
+    lookups: {
+        MicromUsersGroups: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsersGroups;
+        };
+    };
+    clientActions: {
+        ACTEnableMenus: import("src").EntityClientAction;
+        ACTDisableMenus: import("src").EntityClientAction;
+    };
+    constructor();
+}
+export interface MicromUsersGroupsMenusEntityProps {
+    icon?: (props: IconProps) => ReactNode;
+    helpText?: string;
+    title: string;
+}
+export const MicromUsersGroupsMenusEntityDefaultProps: Partial<MicromUsersGroupsMenusEntityProps>;
+export class MicromUsersGroupsMenus extends Entity<MicromUsersGroupsMenusDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export interface MicromUsersGroupsFormProps extends FormOptions<MicromUsersGroups> {
+    groupTabLabel?: string;
+    menusTabLabel?: string;
+    membersTabLabel?: string;
+}
+export const MicromUsersGroupsFormDefaultProps: Partial<MicromUsersGroupsFormProps>;
+export function MicromUsersGroupsForm(props: MicromUsersGroupsFormProps): import("react/jsx-runtime").JSX.Element;
+export class MicromUsersGroups extends Entity<MicromUsersGroupsDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class MicromUsersDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_user_id: EntityColumn<string>;
+        vc_username: EntityColumn<string>;
+        vc_email: EntityColumn<string>;
+        vc_pwhash: EntityColumn<string>;
+        vb_sid: EntityColumn<string>;
+        vc_refreshtoken: EntityColumn<string>;
+        dt_refresh_expiration: EntityColumn<boolean>;
+        i_badlogonattempts: EntityColumn<number>;
+        i_refreshcount: EntityColumn<number>;
+        bt_disabled: EntityColumn<boolean>;
+        dt_locked: EntityColumn<Date>;
+        dt_last_login: EntityColumn<Date>;
+        dt_last_refresh: EntityColumn<Date>;
+        vc_recovery_code: EntityColumn<string>;
+        dt_last_recovery: EntityColumn<Date>;
+        c_usertype_id: EntityColumn<string>;
+        vc_user_groups: EntityColumn<string[]>;
+        bt_islocked: EntityColumn<boolean>;
+        i_locked_minutes_remaining: EntityColumn<number>;
+        vc_password: EntityColumn<string>;
+    };
+    views: {
+        usr_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_user_id: number;
+            };
+        };
+    };
+    lookups: {
+        UserTypes: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => catUserTypes;
+        };
+        MicromUsersGroups: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsersGroups;
+        };
+    };
+    constructor();
+}
+export interface MicromUsersFormProps extends FormOptions<MicromUsers> {
+    disabledTrueLabel?: string;
+    disabledFalseLabel?: string;
+    lockedRemainingLabel?: string;
+    userEnabledLabel?: string;
+    userDisabledLabel?: string;
+    logonAttemptsStatusTitle?: string;
+    logonAttemptsStatusDescription?: string;
+    lockedTitleLabel?: string;
+    minutesLabel?: string;
+    willUnlockInNextLogonLabel?: string;
+}
+export const MicromUsersFormDefaultProps: Partial<MicromUsersFormProps>;
+export function MicromUsersForm(props: MicromUsersFormProps): import("react/jsx-runtime").JSX.Element;
+export class MicromUsers extends Entity<MicromUsersDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export interface IMicromUserStatusPanelColums {
+    vc_username: EntityColumn<string>;
+    vc_password: EntityColumn<string>;
+    bt_islocked: EntityColumn<boolean>;
+    bt_disabled: EntityColumn<boolean>;
+    i_badlogonattempts: EntityColumn<number>;
+    i_locked_minutes_remaining: EntityColumn<number>;
+    dt_locked: EntityColumn<Date>;
+    dt_last_login: EntityColumn<Date>;
+    dt_last_refresh: EntityColumn<Date>;
+    vc_user_groups: EntityColumn<string[]>;
+}
+export const MicromUserStatusPanelColumsKeys: string[];
+export const MicromUserStatusPanelColumns: (default_groups?: string[]) => IMicromUserStatusPanelColums;
+export const MicromUsersStatusPanelLookups: () => {
+    MicromUsersGroups: {
+        name: string;
+        viewMapping: {
+            keyIndex: number;
+            descriptionIndex: number;
+        };
+        entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsersGroups;
+    };
+};
+export interface MicromUsersStatusPanel {
+    columns: IMicromUserStatusPanelColums;
+    maxBadLogonAttemps: number;
+    entityForm: UseEntityFormReturnType;
+    disabledTrueLabel?: string;
+    disabledFalseLabel?: string;
+    lockedRemainingLabel?: string;
+    userEnabledLabel?: string;
+    userDisabledLabel?: string;
+    logonAttemptsStatusTitle?: string;
+    logonAttemptsStatusDescription?: string;
+    lockedTitleLabel?: string;
+    minutesLabel?: string;
+    willUnlockInNextLogonLabel?: string;
+    loginInfoTitle?: string;
+}
+export const MicromUsersStatusPanelDefaultProps: Partial<MicromUsersStatusPanel>;
+export function MicromMUsersStatusPanel(props: MicromUsersStatusPanel): import("react/jsx-runtime").JSX.Element;
+export class FileStoreProcessDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_fileprocess_id: EntityColumn<string>;
+    };
+    views: {
+        fsp_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_fileprocess_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class FileStoreProcess extends Entity<FileStoreProcessDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class FileStoreDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_file_id: EntityColumn<string>;
+        c_fileprocess_id: EntityColumn<string>;
+        vc_filename: EntityColumn<string>;
+        vc_filefolder: EntityColumn<string>;
+        vc_fileguid: EntityColumn<string>;
+        bi_filesize: EntityColumn<number>;
+        c_fileuploadstatus_id: EntityColumn<string>;
+    };
+    views: {
+        fst_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_file_id: number;
+            };
+        };
+        fst_brwFiles: {
+            name: string;
+            keyMappings: {
+                c_file_id: number;
+                c_fileprocess_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class FileStore extends Entity<FileStoreDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class FileStoreStatusDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_file_id: EntityColumn<string>;
+        c_status_id: EntityColumn<string>;
+        c_statusvalue_id: EntityColumn<string>;
+    };
+    views: {
+        fsts_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_status_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class FileStoreStatus extends Entity<FileStoreStatusDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class StatusDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_status_id: EntityColumn<string>;
+        vc_description: EntityColumn<string>;
+    };
+    views: {
+        sta_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_status_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class Status extends Entity<StatusDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class StatusValuesDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_status_id: EntityColumn<string>;
+        c_statusvalue_id: EntityColumn<string>;
+        vc_description: EntityColumn<string>;
+        bt_initial_value: EntityColumn<boolean>;
+    };
+    views: {
+        stv_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_statusvalue_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export class StatusValues extends Entity<StatusValuesDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class MicromUsersGroupsMembersDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_user_group_id: EntityColumn<string>;
+        c_user_id: EntityColumn<string>;
+    };
+    views: {
+        mgm_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_user_id: number;
+            };
+        };
+    };
+    lookups: {
+        MicromUsers: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsers;
+        };
+        MicromUsersGroups: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => MicromUsersGroups;
+        };
+    };
+    constructor();
+}
+export class MicromUsersGroupsMembers extends Entity<MicromUsersGroupsMembersDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export class ImportEntityDataDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_fileprocess_id: EntityColumn<string>;
+    };
+    views: {
+        ipr_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_import_process: number;
+            };
+        };
+    };
+    lookups: {
+        FileStoreProcess: {
+            name: string;
+            viewMapping: {
+                keyIndex: number;
+                descriptionIndex: number;
+            };
+            entityConstructor: (client: MicroMClient, parentKeys?: ValuesObject) => FileStoreProcess;
+        };
+    };
+    constructor();
+}
+export interface CircleFilledIconProps {
+    backColor?: MantineColor;
+    color?: MantineColor;
+    width?: string | number;
+    minWidth?: string | number;
+    icon: ReactNode;
+    mr?: string;
+}
+export const CircleFilledIconDefaultProps: Partial<CircleFilledIconProps>;
+export const CircleFilledIcon: import("react").ForwardRefExoticComponent<CircleFilledIconProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface ImportEntityDataLabels {
+    Icon?: (props: IconProps) => ReactNode;
+    Title?: string;
+    HelpText?: string;
+}
+export const ImportEntityDataLabels: Partial<ImportEntityDataLabels>;
+export class ImportEntityData extends Entity<ImportEntityDataDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export interface ImportEntityDataFormProps extends FormOptions<ImportEntityData> {
+    importEntity?: Entity<EntityDefinition>;
+    importInfoLabel?: string;
+    csvInstructionsLabel?: string;
+    columnHeaderLabel?: string;
+    dataNameLabel?: string;
+    contentLabel?: string;
+    dataTypeLabel?: string;
+    errorReadingFileLabel?: string;
+    emptyCSVFileLabel?: string;
+    missingColumnsLabel?: string;
+    dateFormatLabel?: string;
+    numberFormatLabel?: string;
+    downloadSampleLabel?: string;
+    importButtonLabel?: string;
+    importHelpAndInstructionsLabel?: string;
+    recordsImportedSusccessfullyLabel?: string;
+    recordsNotImportedDueToErrorsLabel?: string;
+    importTheCSVFileLabel?: string;
+    importedFileLabel?: string;
+    errorColumnTitle?: string;
+    rowColumnTitle?: string;
+}
+export const ImportEntityDataFormDefaultProps: Partial<ImportEntityDataFormProps>;
+export function ImportEntityDataForm(props: ImportEntityDataFormProps): import("react/jsx-runtime").JSX.Element;
+export class EmailServiceConfigurationDef extends EntityDefinition {
+    columns: {
+        dt_inserttime: EntityColumn<Date>;
+        dt_lu: EntityColumn<Date>;
+        vc_webinsuser: EntityColumn<string>;
+        vc_webluuser: EntityColumn<string>;
+        vc_insuser: EntityColumn<string>;
+        vc_luuser: EntityColumn<string>;
+        c_email_configuration_id: EntityColumn<string>;
+        vc_smtp_host: EntityColumn<string>;
+        i_smtp_port: EntityColumn<number>;
+        vc_user_name: EntityColumn<string>;
+        vc_password: EntityColumn<string>;
+        bt_use_ssl: EntityColumn<boolean>;
+        vc_default_sender_email: EntityColumn<string>;
+        vc_default_sender_name: EntityColumn<string>;
+        vc_template_subject: EntityColumn<string>;
+        vc_template_body: EntityColumn<string>;
+    };
+    views: {
+        eqc_brwStandard: {
+            name: string;
+            keyMappings: {
+                c_email_configuration_id: number;
+            };
+        };
+    };
+    constructor();
+}
+export interface EmailServiceConfigurationFormProps extends FormOptions<EmailServiceConfiguration> {
+    settingsTABLabel?: string;
+    settingsTABIcon?: ReactNode;
+    recoveryTABLabel?: string;
+    recoveryTABIcon?: ReactNode;
+    setDefaultMessageButtonLabel?: string;
+}
+export const EmailServiceConfigurationFormDefaultProps: Partial<EmailServiceConfigurationFormProps>;
+export function EmailServiceConfigurationForm(props: EmailServiceConfigurationFormProps): import("react/jsx-runtime").JSX.Element;
+export const EmailServiceConfigurationIcon: import("react").ForwardRefExoticComponent<import("@tabler/icons-react").IconProps & import("react").RefAttributes<import("@tabler/icons-react").Icon>>;
+export const EmailServiceConfigurationHelpText = "* Configure your email server settings.";
+export const EmailServiceConfigurationTitle = "Email Service Configuration";
+export class EmailServiceConfiguration extends Entity<EmailServiceConfigurationDef> {
+    constructor(client: MicroMClient, parentKeys?: {});
+}
+export interface UseFileUploadReturnType {
+    uploadFiles: (selectedFiles: File[]) => Promise<void>;
+    deleteFile: (file_id: string, fileGUID: string) => Promise<DBStatusResult>;
+    downloadFile: (fileUrl: string, fileName?: string) => Promise<void>;
+    uploadProgress: Record<string, UploadProgressReport>;
+    fileProcessID: string;
+    maxIndividualFileSize?: number;
+    maxTotalFilesSize?: number;
+    maxFilesCount?: number;
+    errorNotification?: string;
+    cancelledNotification?: boolean;
+    uploadingNotification?: boolean;
+    clearNotifications?: () => void;
+    cancelUpload?: () => void;
+    loadingNotification?: boolean;
+}
+export type ValidateFileReturnType = {
+    error: boolean;
+    message?: string;
+};
+export interface UseFileUploadProps {
+    client: MicroMClient;
+    fileProcessColumn: EntityColumn<string>;
+    maxIndividualFileSize?: number;
+    maxTotalFilesSize?: number;
+    maxFilesCount?: number;
+    youCanUploadAMaximumOfText?: string;
+    filesText?: string;
+    exceedMaximumIndividualSizeText?: string;
+    unspecifiedErrorWhenUploadingFileText?: string;
+    totalUploadExceedsMaximumSizeText?: string;
+    onCancel?: () => void;
+    editor?: 'none' | 'image';
+    onValidateFile?: (file: File) => Promise<ValidateFileReturnType>;
+    thumbnailMaxSize?: number;
+    thumbnailQuality?: number;
+}
+export const UseFileUploadDefaultProps: Partial<UseFileUploadProps>;
+export interface UploadProgressReport {
+    errorMessage?: string;
+    status_id: string;
+    file_id?: string;
+    progress: number;
+    done?: boolean;
+    cancelled?: boolean;
+    documentURL?: string;
+    file_name: string;
+    file_size: number;
+    vc_fileguid?: string;
+    thumbnailURL?: string;
+}
+export type UploadStatus = 'Pending' | 'Uploading' | 'Uploaded' | 'Failed' | 'Cancelled';
+export type FileUploaderView = {
+    c_file_id: string;
+    vc_filename: string;
+    vc_filefolder: string;
+    vc_fileguid: string;
+    c_fileuploadstatus_id: string;
+    bi_filesize: number;
+};
+export function useFileUpload(props: UseFileUploadProps): UseFileUploadReturnType;
+export interface FilePreviewProps {
+    documentURL: string;
+    onClose: () => void;
+    closeText: string;
+    filePreviewError?: string;
+}
+export function ImagePreview({ documentURL, onClose, closeText }: FilePreviewProps): import("react/jsx-runtime").JSX.Element;
+export const PDFPreviewDefaultProps: Partial<FilePreviewProps>;
+export function PDFPreview(props: FilePreviewProps): import("react/jsx-runtime").JSX.Element;
+export type PreviewFileTypes = 'image' | 'pdf' | 'other';
+export const getFileType: (file_name: string) => PreviewFileTypes;
+export interface FileUploaderProps extends Omit<DropzoneProps, 'children' | 'onDrop' | 'maxSize' | 'maxFiles'> {
+    IdleIcon?: (props: IconProps) => ReactNode;
+    UploadText?: string;
+    AttachUpToText?: string;
+    FilesText?: string;
+    EachFileShouldNotExceedText?: string;
+    uploadAPI: UseFileUploadReturnType;
+    onDelete?: (file_id: string) => boolean;
+    imageProps?: ImageProps;
+    closeText?: string;
+    cancelledText?: string;
+    operationCancelledText?: string;
+    pdfCannotBeViewedText?: string;
+    showCancelButton?: boolean;
+    cancelLabel?: string;
+}
+export const FileUploaderDefaultProps: Partial<FileUploaderProps>;
+export function FileUploader(props: FileUploaderProps): import("react/jsx-runtime").JSX.Element;
+export interface FilesUploadFormProps extends UseFileUploadProps {
+    fileProcessColumn: EntityColumn<string>;
+    onOK?: (fileprocess_id: string, uploadProgress: Record<string, UploadProgressReport>) => void;
+    onDelete?: (file_id: string) => boolean;
+    helpMessage?: string;
+    uploaderProps?: Omit<FileUploaderProps, 'uploadAPI' | 'abortSignal'>;
+    okLabel?: string;
+    showOKButton?: boolean;
+    editor?: 'none' | 'image';
+    onValidateFile?: (file: File) => Promise<ValidateFileReturnType>;
+}
+export const FilesUploadFormDefaultProps: Partial<FilesUploadFormProps>;
+export function FilesUploadForm(props: FilesUploadFormProps): import("react/jsx-runtime").JSX.Element;
+export interface ModalFileUploadProps {
+    client: MicroMClient;
+    fileProcessColumn: EntityColumn<string>;
+    onOK?: (fileprocess_id: string, uploadProgress: Record<string, UploadProgressReport>) => void;
+    onCancel?: () => void;
+    onClosed?: () => void;
+    modalProps?: ModalSettings;
+    modalTitle?: string;
+    filesUploadFormProps: Omit<FilesUploadFormProps, 'fileProcessColumn' | 'uploaderProps' | 'client' | 'onOK' | 'onCancel'>;
+    uploaderProps?: Omit<FileUploaderProps, 'uploadAPI' | 'abortSignal'>;
+}
+export const UseFileUploadFormOpenDefaultProps: Partial<ModalFileUploadProps>;
+export function useFilesUploadForm(): (props: ModalFileUploadProps) => Promise<void>;
+export interface useEntityCSVImportValidationProps {
+    errorReadingFileLabel?: string;
+    emptyCSVFileLabel?: string;
+    missingColumnsLabel?: string;
+}
+export function useEntityCSVImportValidation({ errorReadingFileLabel, emptyCSVFileLabel, missingColumnsLabel }: useEntityCSVImportValidationProps): {
+    validateEntityImportCSVFile: (props: {
+        file: File;
+        requiredColumns: string[];
+    }) => Promise<ValidateFileReturnType>;
+};
+export function useImportData(importEntity?: Entity<EntityDefinition>): {
+    execute: (fileprocess_id: string) => Promise<OperationStatus<ImpDataResult> | undefined>;
+    importStatus: OperationStatus<ImpDataResult>;
+    cancellation: AbortController;
+};
+export interface MicroMClientClaimTypes {
+    username: string;
+    useremail?: string;
+    userinitials?: string;
+    [k: string]: unknown;
+}
+export class MicroMToken {
+    expiration: string;
+    expires_in: number;
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    claims: Partial<MicroMClientClaimTypes>;
+    constructor(access_token?: string, expires_in?: number, refresh_token?: string, token_type?: string, claims?: {});
+    className(): string;
+}
+export type DataOperationType = "add" | "edit" | "delete" | "get" | "lookup" | "view" | "action" | "login" | "refresh" | "proc" | "import" | "other";
+export interface OperationStatus<T> {
+    loading?: boolean;
+    error?: MicroMError;
+    operationType?: DataOperationType;
+    data?: T;
+}
+export type StatusCompletedHandler<T extends MicroMToken | DBStatusResult | DataResult | ValuesObject | null> = (status: OperationStatus<T>) => void;
+export interface UseImportDataProps {
+    initialFormMode: FormMode;
+    title?: string;
+    element?: HTMLElement;
+    getDataOnInit?: boolean;
+    modalFormSize?: MicroMModalSize;
+    handleModalSaved: (newStatus: OperationStatus<DBStatusResult | null>) => Promise<void>;
+    handleModalCancel: () => Promise<void>;
+    handleModalClosed?: () => void;
+}
+export function useImportDataForm({ initialFormMode, title, element, getDataOnInit, modalFormSize, handleModalCancel, handleModalClosed, handleModalSaved }: UseImportDataProps): {
+    openImportDataForm: (importEntity: Entity<EntityDefinition>) => Promise<void>;
+};
+export interface UseExportToExcelProps {
+    data: DataResult[];
+    dataResultNames?: string[];
+}
+export function useExportToExcel(props: UseExportToExcelProps): {
+    exportToExcel: () => Promise<void>;
+};
+export interface UseViewFiltersProps extends Omit<UseEntityFormOptions, 'noSaveOnSubmit'> {
+}
+export function useViewFiltersForm(props: UseViewFiltersProps): import("src").UseEntityFormReturnType;
+export const ApplyFiltersDefaultLabel = "Apply Filters";
+export function AutoFiltersForm(props: FormOptions<Entity<EntityDefinition>>): import("react/jsx-runtime").JSX.Element;
+export function createEntityForm<T extends FormOptions<Entity<EntityDefinition>>>(props: T): Promise<ReactNode>;
+export interface openEntityFormProps<T extends FormOptions<Entity<EntityDefinition>>> {
+    modals: ModalContextType;
+    title?: string;
+    element?: HTMLElement;
+    handleModalSaved: (newStatus: OperationStatus<DBStatusResult | null>) => Promise<void>;
+    handleModalCancel: () => Promise<void>;
+    handleModalClosed?: () => void;
+    modalFormSize?: MicroMModalSize;
+    formProps: T;
+}
+export function openEntityForm<T extends FormOptions<Entity<EntityDefinition>>>({ modals, title, element, handleModalCancel, handleModalSaved, modalFormSize, formProps, handleModalClosed }: openEntityFormProps<T>): Promise<void>;
+export interface EntityUILabels {
+    addLabel: string;
+    editLabel: string;
+    deleteLabel: string;
+    viewLabel: string;
+    YouWillDeleteLabel: string;
+    recordsLabel: string;
+    recordLabel: string;
+    AreYouSureLabel: string;
+    warningLabel: string;
+    YouMustSelectOneOrMoreRecordsToDelete: string;
+    closeLabel: string;
+    YouMustSelectOneOrMoreRecordsToExecuteAction: string;
+    YouMustSelect: string;
+    YouMustSelectBetween: string;
+    YouMustSelectAtLeast: string;
+    YouMustSelectMaximum: string;
+}
+export interface UseEntityUIProps {
+    entity?: Entity<EntityDefinition>;
+    parentKeys?: ValuesObject;
+    modalFormSize?: MicroMModalSize;
+    parentFormAPI?: UseEntityFormReturnType;
+    saveFormBeforeAdd?: boolean;
+    onModalSaved?: (new_status: OperationStatus<DBStatusResult | null>) => void;
+    onModalCancelled?: () => void;
+    onRecordsDeleted?: () => void;
+    onActionRefreshOnClose?: () => void;
+    labels?: EntityUILabels;
+    onAddClick?: (gridAddClick: (element?: HTMLElement) => void, element?: HTMLElement) => void;
+    onEditClick?: (keys: ValuesObject, element?: HTMLElement) => void;
+    onDeleteClick?: (keys: ValuesObject[], element?: HTMLElement) => void;
+    onActionExecuted?: (actionName: string, result?: boolean) => void;
+    onModalClosed?: (cancelled?: boolean) => void;
+}
+export function useEntityUI(props: UseEntityUIProps): {
+    handleAddClick: (element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+    handleEditClick: (keys: ValuesObject, element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+    handleViewClick: (keys: ValuesObject, element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+    handleDeleteClick: (keys: ValuesObject[], element?: HTMLElement) => Promise<void>;
+    handleExecuteAction: (action: EntityClientAction, keys: ValuesObject[], element?: HTMLElement) => Promise<boolean | undefined>;
+    handleDeleteRecord: (keys: ValuesObject, element?: HTMLElement) => Promise<void>;
+    handleImportDataClick: () => Promise<void>;
+};
+export function useExecuteProc(entity: Entity<EntityDefinition>, proc: EntityProc): {
+    execute: (values?: ValuesObject) => Promise<OperationStatus<DataResult[]> | undefined>;
+    status: OperationStatus<DataResult[]>;
+};
+export interface SearchFilterInputProps extends MultiSelectProps {
+    onSearchClick: React.MouseEventHandler;
+    size: string;
+    iconsSize: string;
+    placeholder?: string;
+    autoFocus?: boolean;
+    addFilterLabel?: string;
+    iconVariant?: ActionIconVariant;
+    [x: string]: any;
+}
+export const SearchFilterInputDefaultProps: Partial<SearchFilterInputProps>;
+export function SearchFilterInput(props: SearchFilterInputProps): import("react/jsx-runtime").JSX.Element;
+export function useFirstVisible(ref: React.RefObject<HTMLElement>, options?: IntersectionObserverInit): boolean;
+export interface OpenFormProps {
+    entity: Entity<EntityDefinition>;
+    initialFormMode: FormMode;
+    title?: string;
+    element?: HTMLElement;
+    getDataOnInit?: boolean;
+    onModalSaved?: (new_status: OperationStatus<DBStatusResult | null>) => void;
+    onModalCancelled?: () => void;
+    onModalClosed?: () => void;
+    modalFormSize?: MicroMModalSize;
+    OKText?: string;
+    CancelText?: string;
+    showCancel?: boolean;
+    otherFormProps?: any;
+    dontAddEntityTitle?: boolean;
+}
+export function useOpenForm(): (props: OpenFormProps) => Promise<void>;
+export declare namespace query {
+    export function html(str: any): Query | undefined;
+    import version = Query.version;
+    export { version };
+}
+export declare namespace w2locale {
+    let locale: string;
+    let dateFormat: string;
+    let timeFormat: string;
+    let datetimeFormat: string;
+    let currencyPrefix: string;
+    let currencySuffix: string;
+    let currencyPrecision: number;
+    let groupSymbol: string;
+    let decimalSymbol: string;
+    let shortmonths: string[];
+    let fullmonths: string[];
+    let shortdays: string[];
+    let fulldays: string[];
+    let weekStarts: string;
+    let phrases: {
+        '${count} letters or more...': string;
+        'Add new record': string;
+        'Add New': string;
+        'Advanced Search': string;
+        after: string;
+        'AJAX error. See console for more details.': string;
+        'All Fields': string;
+        All: string;
+        Any: string;
+        'Are you sure you want to delete ${count} ${records}?': string;
+        'Attach files by dragging and dropping or Click to Select': string;
+        before: string;
+        'begins with': string;
+        begins: string;
+        between: string;
+        buffered: string;
+        Cancel: string;
+        Close: string;
+        Column: string;
+        Confirmation: string;
+        contains: string;
+        Copied: string;
+        'Copy to clipboard': string;
+        'Current Date & Time': string;
+        'Delete selected records': string;
+        Delete: string;
+        'Do you want to delete search item "${item}"?': string;
+        'Edit selected record': string;
+        Edit: string;
+        'Empty list': string;
+        'ends with': string;
+        ends: string;
+        'Field should be at least ${count} characters.': string;
+        Hide: string;
+        in: string;
+        'is not': string;
+        is: string;
+        'less than': string;
+        'Line #': string;
+        'Load ${count} more...': string;
+        'Loading...': string;
+        'Maximum number of files is ${count}': string;
+        'Maximum total size is ${count}': string;
+        Modified: string;
+        'more than': string;
+        'Multiple Fields': string;
+        Name: string;
+        'No items found': string;
+        'No matches': string;
+        No: string;
+        none: string;
+        'Not a float': string;
+        'Not a hex number': string;
+        'Not a valid date': string;
+        'Not a valid email': string;
+        'Not alpha-numeric': string;
+        'Not an integer': string;
+        'Not in money format': string;
+        'not in': string;
+        Notification: string;
+        of: string;
+        Ok: string;
+        Opacity: string;
+        'Record ID': string;
+        record: string;
+        records: string;
+        'Refreshing...': string;
+        'Reload data in the list': string;
+        Remove: string;
+        'Remove This Field': string;
+        'Request aborted.': string;
+        'Required field': string;
+        Reset: string;
+        'Restore Default State': string;
+        'Returned data is not in valid JSON format.': string;
+        'Save changed records': string;
+        'Save Grid State': string;
+        Save: string;
+        'Saved Searches': string;
+        'Saving...': string;
+        'Search took ${count} seconds': string;
+        Search: string;
+        'Select Hour': string;
+        'Select Minute': string;
+        selected: string;
+        'Server Response ${count} seconds': string;
+        'Show/hide columns': string;
+        Show: string;
+        Size: string;
+        Skip: string;
+        'Sorting took ${count} seconds': string;
+        'Type to search...': string;
+        Type: string;
+        Yes: string;
+        Yesterday: string;
+        'Your remote data source record count has changed, reloading from the first record.': string;
+    };
+}
+type w2record = Record<string, unknown> & {
+    recid: number;
+};
+type w2recordId = string | number;
+type w2columnField = string;
+export type GridSelectionMode = 'multi' | 'single';
+export type GridColumnFormat = 'url' | 'email' | 'string' | 'check' | 'image' | 'html';
+export type GridColumnRender = (value: unknown, cellElement?: HTMLElement, record?: GridRecord, field?: w2columnField) => ReactNode;
+export type GridRecord = w2record;
+export type GridSourceRecord = Record<string | number, unknown> | unknown[];
+export type GridRecordId = w2recordId;
+export type GridColumn = {
+    field: string;
+    text: string;
+    hidden?: boolean;
+    format?: GridColumnFormat;
+    autoSizeMax?: number;
+    render?: GridColumnRender;
+    sqlType?: SQLType;
+};
+export type GridColumnsOverrides = Record<string | number, Partial<GridColumn>>;
+export type GridSelection = GridRecord[];
+export type GridDoubleClickCallback = (record: GridRecord) => void;
+export type GridSelectionChangedCallback = (selection: GridSelection) => void;
+export type GridOptions = {
+    columns?: GridColumn[];
+    rows?: GridSourceRecord[];
+    gridHeight?: string | number | 'auto';
+    selectionMode?: GridSelectionMode;
+    onDoubleClick?: GridDoubleClickCallback;
+    preserveSelection?: boolean;
+    autoSelectFirstRow?: boolean;
+    onSelectionChanged?: GridSelectionChangedCallback;
+    showSelectCheckbox?: boolean;
+    rowHeight?: number;
+    stripped?: boolean;
+    highlightOnHover?: boolean;
+    columnBorders?: boolean;
+    rowBorders?: boolean;
+    withBorder?: boolean;
+    autoSizeColumnsOnLoad?: boolean;
+    columnsOverrides?: GridColumnsOverrides;
+    selectedRows?: GridSelection;
+    setSelectedRows?: (rows: GridSelection) => void;
+};
+export type GridImperative = {};
+export const DefaultGridProps: Partial<GridOptions>;
+export const DefaultGridColumnProps: Partial<GridColumn>;
+export const Grid: import("react").ForwardRefExoticComponent<GridOptions & import("react").RefAttributes<GridImperative>>;
+export function GridGlobalStyles(): import("react/jsx-runtime").JSX.Element;
+export interface UseDataGridToolbarFiltersProps {
+    filterValues: ValuesObject | undefined;
+    setFilterValues: Dispatch<SetStateAction<ValuesObject | undefined>>;
+    filtersDescription: ValuesObject | undefined;
+    setFiltersDescription: Dispatch<SetStateAction<ValuesObject | undefined>>;
+    client?: MicroMClient;
+    parentKeys?: ValuesObject;
+    FiltersEntity?: EntityConstructor;
+    searchData: SelectItem[];
+    setSearchData: Dispatch<SetStateAction<SelectItem[]>>;
+    setSearchText: Dispatch<SetStateAction<string[] | undefined>>;
+    onRefreshClick: (searchText: string[] | undefined) => void;
+    onSearchTextChange?: (text: string[] | undefined) => void;
+    filtersFormSize: MantineNumberSize;
+    visibleFilters?: string[];
+    initialColumnFilters?: ColumnsObject;
+}
+export function useDataGridToolbarFilters(props: UseDataGridToolbarFiltersProps): {
+    handleFilterButtonClick: (e: React.MouseEvent) => Promise<void>;
+    handleSearchFilterInputEnter: (e: React.KeyboardEvent) => void;
+    handleClearFiltersClick: (e: React.MouseEvent) => void;
+    createSearchPhrase: (filter: string) => {
+        value: string;
+        label: string;
+    };
+    queryText: string;
+    filtersDescription: ValuesObject | undefined;
+    setFiltersDescription: Dispatch<SetStateAction<ValuesObject | undefined>>;
+    setQueryText: Dispatch<SetStateAction<string>>;
+    handleSearchFilterInputOnChange: (searchFilter: string[]) => void;
+    updateFilterValuesAndDescription: (columns: ColumnsObject) => void;
+};
+export type DataGridToolbarSizes = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface DataGridToolbarOptions {
+    size?: DataGridToolbarSizes;
+    client?: MicroMClient;
+    searchPlaceholder?: string;
+    hideCheckboxToggle?: boolean;
+    onCheckboxToggle?: () => void;
+    onSearchTextChange?: (text: string[] | undefined) => void;
+    onRefreshClick: (searchText: string[] | undefined) => void;
+    onExportClick: () => void;
+    autoFocus?: boolean;
+    toolbarIconVariant?: ActionIconVariant;
+    enableExport?: boolean;
+    refreshTooltip?: string;
+    exportTooltip?: string;
+    selectRowsTooltip?: string;
+    searchText: string[] | undefined;
+    setSearchText: Dispatch<SetStateAction<string[] | undefined>>;
+    searchData: SelectItem[];
+    setSearchData: Dispatch<SetStateAction<SelectItem[]>>;
+    FiltersEntity?: EntityConstructor;
+    filterTooltip?: string;
+    parentKeys?: ValuesObject;
+    filterValues: ValuesObject | undefined;
+    setFilterValues: Dispatch<SetStateAction<ValuesObject | undefined>>;
+    filtersDescription: ValuesObject | undefined;
+    setFiltersDescription: Dispatch<SetStateAction<ValuesObject | undefined>>;
+    clearFiltersTooltip?: string;
+    filtersFormSize: MantineNumberSize;
+    enableImport?: boolean;
+    importTooltip?: string;
+    onImportClick?: () => void;
+    filtersBadgeSize?: MantineSize;
+    filtersBadgeVariant?: BadgeVariant;
+    showAppliedFilters?: boolean;
+    showRefreshButton?: boolean;
+    showSelectRowsButton?: boolean;
+    showFiltersButton?: boolean;
+    showSearchInput?: boolean;
+    visibleFilters?: string[];
+    initialColumnFilters?: ColumnsObject;
+    filtersTitle?: string;
+    editFitersLabel?: string;
+    clearFiltersLabel?: string;
+    filtersAccordionVariant?: AccordionVariant;
+}
+export const DataGridToolbarDefaultProps: Partial<DataGridToolbarOptions>;
+export function DataGridToolbar(props: DataGridToolbarOptions): import("react/jsx-runtime").JSX.Element;
+export const DataGridDefaultProps: Partial<DataGridProps>;
+export function DataGrid(props: DataGridProps): import("react/jsx-runtime").JSX.Element;
+export interface DataGridFormProps extends DataGridProps {
+    customTitle?: ReactNode;
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    showTitle?: boolean;
+}
+export const DataGridFormDefaultProps: Partial<DataGridFormProps>;
+export function DataGridForm(props: DataGridFormProps): import("react/jsx-runtime").JSX.Element;
+export interface useDataGridFormType {
+    open: ({ entity, viewName, onClosed, selectionMode, modalProps, search, modalTitle, gridTitle }: ModalDataGridProps) => void;
+}
+export interface ModalDataGridProps {
+    entity: Entity<EntityDefinition>;
+    viewName: string;
+    onClosed?: () => void;
+    modalProps?: ModalSettings;
+    selectionMode?: GridSelectionMode;
+    search?: string[] | undefined;
+    modalTitle?: string;
+    gridTitle?: React.ReactNode;
+    formMode: FormMode;
+}
+export function useDataGridForm(): (props: ModalDataGridProps) => Promise<void>;
+export interface DataGridPageProps extends Omit<DataGridProps, 'entity' | 'title'> {
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    client: MicroMClient;
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+    showTitle?: boolean;
+}
+export const DataGridPageDefaultProps: Partial<DataGridPageProps>;
+export function DataGridPage(props: DataGridPageProps): import("react/jsx-runtime").JSX.Element;
+export interface EntityCardProps<T extends ValuesObject> {
+    entity: Entity<EntityDefinition>;
+    recordIndex: number;
+    record: DataViewRecord<T>;
+    selected?: boolean;
+    toggleSelectable?: boolean;
+    enableEdit?: boolean;
+    enableDelete?: boolean;
+    enableView?: boolean;
+    handleEditClick?: (keys: ValuesObject, element: HTMLElement) => void;
+    handleDeleteClick?: (keys: ValuesObject, element: HTMLElement) => void;
+    handleViewClick?: (keys: ValuesObject, element: HTMLElement) => void;
+    handleSelectRecord?: (record_index: number) => void;
+    handleDeselectRecord?: (record_index: number) => void;
+    handleCardClick?: (data: T) => void;
+    refreshView?: () => void;
+    cardHrefRootURL?: string;
+    cardHrefTarget?: string;
+}
+export const DataViewDefaultProps: Partial<DataViewProps>;
+export const DataView: import("react").ForwardRefExoticComponent<DataViewProps & import("react").RefAttributes<HTMLElement>>;
+export interface DataViewCardContainerProps extends EntityCardProps<ValuesObject> {
+    EntityCard?: ComponentType<EntityCardProps<ValuesObject>>;
+    CardProps?: Omit<CardProps, 'children'>;
+}
+export const DataViewCardContainerDefaultProps: Partial<DataViewCardContainerProps>;
+export function DataViewCardContainer(props: DataViewCardContainerProps): import("react/jsx-runtime").JSX.Element;
+export type DataViewLimit = '50' | '100' | '500' | '1000' | '10000' | '0';
+export const DataViewLimitData: (rowsLabel: string, unlimitedLabel: string) => SelectItem[];
+export type DataViewSelection = number[];
+export interface DataViewRecord<T extends ValuesObject> {
+    keys: ValuesObject;
+    data: T;
+}
+export type DataViewSelectionChangedCallback = (selection: DataViewSelection, keys: ValuesObject[]) => void;
+export type DataViewSelectionChangedHandler = (selection: DataViewSelection) => void;
+export type DataViewSelectionMode = 'single' | 'multi';
+export interface DataViewLabels extends EntityUILabels {
+    rowsReturnedLabel: string;
+    selectedRowsLabel: string;
+    limitLabel: string;
+    rowsLabel: string;
+    unlimitedLabel: string;
+    resultLimitLabel: string;
+    loadMoreLabel: string;
+    fetchingDataLabel: string;
+    noRecordsFoundLabel: string;
+}
+export interface DataViewProps extends Omit<UseEntityUIProps, 'labels'> {
+    viewName: string;
+    search?: string[];
+    limit?: DataViewLimit;
+    refreshOnInit?: boolean;
+    selectionMode: DataViewSelectionMode;
+    preserveSelection?: boolean;
+    autoFocus?: boolean;
+    onDataRefresh?: (result: OperationStatus<DataResult[]>) => void;
+    allwaysRefreshOnEntityClose?: boolean;
+    toolbarIconVariant?: ActionIconVariant;
+    actionsButtonVariant?: ButtonVariant;
+    toolbarSize?: DataGridToolbarSizes;
+    enableAdd?: boolean;
+    enableEdit?: boolean;
+    enableDelete?: boolean;
+    enableView?: boolean;
+    enableExport?: boolean;
+    filtersFormSize?: MantineNumberSize;
+    setInitialFiltersFromColumns?: boolean;
+    visibleFilters?: string[];
+    showAppliedFilters?: boolean;
+    showRefreshButton?: boolean;
+    showFiltersButton?: boolean;
+    showSearchInput?: boolean;
+    showSelectRowsButton?: boolean;
+    searchPlaceholder?: string;
+    hideCheckboxToggle?: boolean;
+    showActions?: boolean;
+    showToolbar?: boolean;
+    CardContainer?: ComponentType<DataViewCardContainerProps>;
+    cardHrefRootURL?: string;
+    cardHrefTarget?: string;
+    Card: ComponentType<EntityCardProps<ValuesObject>>;
+    onSelectionChanged?: DataViewSelectionChangedCallback;
+    notExportableColumns?: number[];
+    labels?: DataViewLabels;
+    itemsPerPage?: number;
+    convertResultToLocaleString?: boolean;
+}
+export interface DataGridStateProps {
+    setRefresh: React.Dispatch<React.SetStateAction<boolean>>;
+    setSearchText: React.Dispatch<React.SetStateAction<string[] | undefined>>;
+    executeViewState: OperationStatus<DataResult[]>;
+}
+export interface DataGridLabels extends EntityUILabels {
+    rowsReturnedLabel: string;
+    selectedRowsLabel: string;
+    limitLabel: string;
+    rowsLabel: string;
+    unlimitedLabel: string;
+}
+export type DataGridSelectionChangedCallback = (selection: GridSelection, keys: DataGridSelectionKeys) => void;
+export interface DataGridProps extends UseEntityUIProps {
+    viewName?: string;
+    search?: string[];
+    limit?: DataViewLimit;
+    refreshOnInit?: boolean;
+    selectionMode: GridSelectionMode;
+    preserveSelection?: boolean;
+    autoFocus?: boolean;
+    onDataRefresh?: (result: OperationStatus<DataResult[]>) => void;
+    allwaysRefreshOnEntityClose?: boolean;
+    toolbarIconVariant?: ActionIconVariant;
+    actionsButtonVariant?: ButtonVariant;
+    toolbarSize?: DataGridToolbarSizes;
+    enableAdd?: boolean;
+    enableEdit?: boolean;
+    enableDelete?: boolean;
+    enableView?: boolean;
+    enableExport?: boolean;
+    filtersFormSize?: MantineNumberSize;
+    showActions?: boolean;
+    setInitialFiltersFromColumns?: boolean;
+    visibleFilters?: string[];
+    columnBorders?: boolean;
+    rowBorders?: boolean;
+    withBorder?: boolean;
+    autoSizeColumnsOnLoad?: boolean;
+    labels?: DataGridLabels;
+    columnsOverrides?: GridColumnsOverrides;
+    renderOnlyWhenVisible?: boolean;
+    showToolbar?: boolean;
+    showActionsToolbar?: boolean;
+    enableImport?: boolean;
+    gridHeight?: string | number | 'auto';
+    autoSelectFirstRow?: boolean;
+    onSelectionChanged?: DataGridSelectionChangedCallback;
+    doubleClickAction?: 'edit' | 'view' | 'none' | ((record: GridRecord) => void);
+    formMode?: FormMode;
+}
+export type DataGridSelectionKeys = ValuesObject[];
+export interface useDataViewReturnType {
+    handleSelectionChanged: DataViewSelectionChangedHandler;
+    handleDeleteRecord: (keys: ValuesObject, element?: HTMLElement) => Promise<void>;
+    handleDeleteClick: (element?: HTMLElement) => Promise<void>;
+    handleEditClick: (keys: ValuesObject, element?: HTMLElement) => Promise<void>;
+    handleAddClick: (element?: HTMLElement) => Promise<void>;
+    handleViewClick: (keys: ValuesObject, element?: HTMLElement) => Promise<void>;
+    handleToggleSelectable: () => void;
+    handleRefresh: (searchText: string[] | undefined) => void;
+    handleExecuteAction: (action: EntityClientAction, element?: HTMLElement) => Promise<void>;
+    handleExport: () => void;
+    selectedRowsCount: number;
+    limitRows: string | null;
+    setLimitRows: React.Dispatch<React.SetStateAction<string | null>>;
+    showSelectCheckbox: boolean;
+    isLoading: boolean;
+    executeViewState: OperationStatus<DataResult[]>;
+    data: DataViewRecord<ValuesObject>[];
+    handleDeselectAllRecords: () => Promise<void>;
+    handleDeselectRecord: (record_index: number) => Promise<void>;
+    handleSelectRecord: (record_index: number) => Promise<void>;
+    handleSelectAllRecords: () => Promise<void>;
+    selectedRecords: DataViewSelection;
+    toggleSelectable: boolean;
+    handleLoadMore: () => void;
+    displayedItemsCount: number;
+    recordsCount?: number;
+}
+export function useDataView(props: DataViewProps, stateProps: DataGridStateProps): useDataViewReturnType;
+export interface DataViewPageProps extends Omit<DataViewProps, 'entity'> {
+    client: MicroMClient;
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+}
+export function DataViewPage(props: DataViewPageProps): import("react/jsx-runtime").JSX.Element;
+export function useViewState(search?: string[], limit?: DataViewLimit): {
+    searchText: string[] | undefined;
+    setSearchText: import("react").Dispatch<import("react").SetStateAction<string[] | undefined>>;
+    limitRows: string | null;
+    setLimitRows: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    refresh: boolean;
+    setRefresh: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    filterValues: ValuesObject | undefined;
+    setFilterValues: import("react").Dispatch<import("react").SetStateAction<ValuesObject | undefined>>;
+    filtersDescription: ValuesObject | undefined;
+    setFiltersDescription: import("react").Dispatch<import("react").SetStateAction<ValuesObject | undefined>>;
+};
+export interface LookupProps {
+    parentKeys?: ValuesObject;
+    column: EntityColumn<Value>;
+    autoFocus?: boolean;
+    entityForm: UseEntityFormReturnType;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    label?: string;
+    idMaxWidth?: string;
+    icon?: React.ReactNode;
+    iconVariant?: ActionIconVariant;
+    requiredLabel?: string;
+    description?: string;
+    size?: MantineSize;
+    onLookupPerformed?: (lookupResult: LookupResultState) => void;
+}
+export const LookupDefaultProps: Partial<LookupProps>;
+export function Lookup(props: LookupProps): import("react/jsx-runtime").JSX.Element;
+export interface LookupFormProps {
+    dataGridProps: DataGridProps;
+    onOK: (selectedKeys: DataGridSelectionKeys) => void;
+    onCancel?: () => void;
+    helpMessage?: string;
+    okLabel?: string;
+    cancelLabel?: string;
+}
+export const LookupFormDefaultProps: Partial<LookupFormProps>;
+export function LookupForm(props: LookupFormProps): import("react/jsx-runtime").JSX.Element;
+export interface LookupResultState {
+    columnName: string;
+    key: Value;
+    description?: string;
+    error?: boolean;
+    cancel: boolean;
+    updateParentKeys: boolean;
+    errorDescription?: string;
+}
+export interface UseLookupOptions {
+    parentKeys?: ValuesObject;
+    column: string;
+    entityForm: UseEntityFormReturnType;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+    required?: boolean;
+    HTMLDescriptionRef: React.MutableRefObject<any>;
+}
+export interface UseLookupReturnType {
+    status: OperationStatus<ValuesObject>;
+    lookupResult?: LookupResultState;
+    lookupInputProps: any;
+    onBlur: (bindingColumn: string, force?: boolean, event?: React.FocusEvent | null) => void;
+}
+export const useLookup: ({ entityForm, entity, lookupDefName, column, parentKeys, required, HTMLDescriptionRef }: UseLookupOptions) => UseLookupReturnType;
+export interface UseLookupEntityOptions {
+    parentKeys?: ValuesObject;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+}
+export function useLookupEntity({ entity, lookupDefName, parentKeys }: UseLookupEntityOptions): {
+    lookupEntity: Entity<EntityDefinition> | undefined;
+    lookupDef: EntityLookup | undefined;
+    lookupViewName: string;
+};
+export interface useLookupFormType {
+    open: ({ entity, viewName, onOK, onCancel, modalProps, search }: ModalLookupOptions) => void;
+}
+export interface ModalLookupOptions {
+    entity: Entity<EntityDefinition>;
+    viewName: string;
+    onOK: (selectedKeys: ValuesObject[]) => void;
+    onCancel?: () => void;
+    onClosed?: () => void;
+    modalProps?: ModalSettings;
+    selectionMode?: GridSelectionMode;
+    search?: string[];
+    selectLabel?: string;
+    parentKeys?: ValuesObject;
+    showActions?: boolean;
+}
+export const UseLookupFormDefaultProps: Partial<ModalLookupOptions>;
+export function useLookupForm(): (props: ModalLookupOptions) => Promise<void>;
+export interface LookupFormActionProps {
+    lookupEntity: Entity<EntityDefinition>;
+    viewName: string;
+    title: string;
+    onOK: (keys: DataGridSelectionKeys, abortSignal: AbortSignal) => Promise<DBStatusResult>;
+    onCancel?: () => void;
+    onActionFinished?: () => Promise<void>;
+    addingRecords?: string;
+    runOnOpen?: boolean;
+    confirmContent?: React.ReactNode;
+    showActions?: boolean;
+}
+export const LookupFormActionDefaultProps: Partial<LookupFormActionProps>;
+export function LookupFormAction(props: LookupFormActionProps): import("react/jsx-runtime").JSX.Element;
+export function useExecuteLookup({ entity, lookupDefName, parentKeys }: UseLookupEntityOptions): {
+    execute: () => Promise<OperationStatus<string> | undefined>;
+    status: OperationStatus<string>;
+};
+export interface LoginModalFormProps {
+    client: MicroMClient;
+    title?: string;
+    onClose?: () => void;
+    onLoggedIn: (claims?: Partial<MicroMClientClaimTypes>) => void;
+    openState?: boolean;
+    withCloseButton?: boolean;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    overlayProps?: OverlayProps;
+    transitionProps?: Partial<Omit<TransitionProps, 'mounted'>>;
+}
+export const LoginModalFormDefaultProps: Partial<LoginModalFormProps>;
+export function LoginModalForm(props: LoginModalFormProps): import("react/jsx-runtime").JSX.Element;
+export interface WeekPickerProps extends CalendarProps {
+    weekStartDatevalue: Date | null;
+    setWeekStartValue: (value: Date | null) => void;
+    setWeekEndValue?: (value: Date | null) => void;
+    allowDeselect?: boolean;
+}
+export function WeekPicker(props: WeekPickerProps): import("react/jsx-runtime").JSX.Element;
+export interface WeekPickerFieldProps extends Omit<WeekPickerProps, 'weekStartDatevalue' | 'setWeekStartValue' | 'setWeekEndValue'> {
+    weekStartDateColumn: EntityColumn<Date | null>;
+    weekEndDateColumn?: EntityColumn<Date | null>;
+    entityForm: UseEntityFormReturnType;
+    loading?: boolean;
+    disableOnLoading?: boolean;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    accordionVariant?: AccordionProps['variant'];
+    accordionExpanded?: boolean;
+    placeholder?: string;
+    size?: MantineSize;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    label?: string;
+    description?: string;
+}
+export const WeekPickerFieldDefaultProps: Partial<WeekPickerFieldProps>;
+export function WeekPickerField(props: WeekPickerFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface PinFieldProps extends Omit<PinInputProps, 'validate'>, Omit<useTextTransformProps, 'entityForm' | 'column'> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: React.ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+    size?: MantineSize;
+    description?: string;
+    label?: string;
+}
+export const PinFieldDefaultProps: Partial<PinFieldProps>;
+export function PinField(props: PinFieldProps): import("react/jsx-runtime").JSX.Element;
+export function useExecuteProcess(entity: Entity<EntityDefinition>, proc: EntityProc): {
+    execute: (values?: ValuesObject) => Promise<OperationStatus<DBStatusResult> | undefined>;
+    status: OperationStatus<DBStatusResult>;
+};
+export interface UseCompleteFieldFromOtherProps {
+    form: UseFormReturnType<ValuesObject>;
+    originalColumn: EntityColumn<Value>;
+    targetColumn: EntityColumn<Value>;
+    onlyIfEmpty?: boolean;
+    transformValue?: (value: Value) => Value;
+}
+export function useCompleteFieldFromOther({ form, originalColumn, targetColumn, onlyIfEmpty, transformValue }: UseCompleteFieldFromOtherProps): void;
+export interface SwitchFieldProps extends SwitchProps {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    loading?: boolean;
+    disableOnLoading?: boolean;
+    requiredMessage?: ReactNode;
+}
+export function SwitchField(props: SwitchFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface RecoverPasswordOptions {
+    client: MicroMClient;
+    changedSuccessfullyURL?: string;
+    onStatusCompleted?: StatusCompletedHandler<DBStatusResult>;
+    userLabel?: string;
+    userPlaceholder?: string;
+    passwordLabel?: string;
+    passwordPlaceholder?: string;
+    changePasswordLabel?: string;
+    changeErrorMessage?: string;
+    changedSuccessfullyMessage?: string;
+    signInButtonLabel?: string;
+    passwordMinLength?: number;
+    passwordMaxLength?: number;
+}
+export const RecoverPasswordDefaultProps: Partial<RecoverPasswordOptions>;
+export interface RecoverPasswordValues {
+    username: string;
+    password: string;
+    recovery_code: string;
+}
+export function RecoverPassword(props: RecoverPasswordOptions): import("react/jsx-runtime").JSX.Element;
+export interface RecoverPasswordEmailOptions {
+    client: MicroMClient;
+    onStatusCompleted?: StatusCompletedHandler<DBStatusResult>;
+    userLabel?: string;
+    userPlaceholder?: string;
+    emailSentSuccessfullyMessage?: string;
+    sendRecoveryEmailLabel?: string;
+    emailSendErrorMessage?: string;
+    goBackToHomePageLabel?: string;
+}
+export const RecoverPasswordEmailDefaultProps: Partial<RecoverPasswordEmailOptions>;
+export interface RecoverPasswordEmailValues {
+    username: string;
+}
+export function RecoverPasswordEmail(props: RecoverPasswordEmailOptions): import("react/jsx-runtime").JSX.Element;
+export function useEvent<T extends (...args: any[]) => any>(callback: T): T;
+export function moneyFormatter(value: string, currencySymbol: string): string;
+export function moneyParser(value: string): string;
+export interface MoneyRangeFieldProps extends Omit<NumberFieldProps, 'parser' | 'formatter'> {
+    currencySymbol?: string;
+    millionsStep?: number;
+    thousandsStep?: number;
+}
+export const MoneyRangeFieldDefaultProps: Partial<MoneyRangeFieldProps>;
+export function MoneyRangeField(props: MoneyRangeFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface RadioGroupFieldProps extends ComponentPropsWithoutRef<typeof Radio.Group> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+    readOnly?: boolean;
+    showDescription?: boolean;
+}
+export const RadioGroupFieldDefaultProps: Partial<RadioGroupFieldProps>;
+export const RadioGroupField: import("react").ForwardRefExoticComponent<RadioGroupFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface UseLookupSelectOptions {
+    parentKeys?: ValuesObject;
+    selectDataState: useStateReturnType<SelectItem[]>;
+    triggerRefreshState: useStateReturnType<boolean>;
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+    maxItems?: number;
+    includeKeyInDescription?: boolean;
+}
+export const useLookupSelect: (props: UseLookupSelectOptions) => {
+    onEditClick: () => void;
+    inputProps: {
+        value: any;
+        onChange: any;
+        checked?: any;
+        error?: any;
+        onFocus?: any;
+        onBlur?: any;
+    };
+    status: import("src").OperationStatus<import("src").DataResult[]>;
+};
+export interface CustomSelectProps extends Omit<SelectProps, 'data'> {
+}
+export interface LookupSelectOptions {
+    parentKeys?: ValuesObject;
+    column: EntityColumn<Value>;
+    formStatus?: OperationStatus<DBStatusResult | DataResult | ValuesObject>;
+    entityForm: UseEntityFormReturnType;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+    enableEdit?: boolean;
+    selectProps?: CustomSelectProps;
+    editIcon?: React.ReactNode;
+    editIconVariant?: ActionIconVariant;
+    maxItems?: number;
+    requiredLabel?: string;
+    editLabel?: string;
+    includeKeyInDescription?: boolean;
+    withinPortal?: boolean;
+    zIndex?: number;
+    editButtonVariant?: ButtonVariant;
+}
+export const LookupSelectDefaultProps: Partial<LookupSelectOptions>;
+export const LookupSelect: import("react").ForwardRefExoticComponent<LookupSelectOptions & import("react").RefAttributes<HTMLInputElement>>;
+export interface EntityActionButtonProps extends Omit<ButtonProps, 'leftIcon'> {
+    entity: Entity<EntityDefinition>;
+    action: EntityClientAction;
+    selectedKeys?: ValuesObject[];
+    label?: string;
+    onClose?: (result?: boolean) => Promise<boolean>;
+}
+export function EntityActionButton(props: EntityActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export interface RingProgressFieldProps extends Omit<CardProps, 'children'> {
+    column: EntityColumn<number>;
+    loading?: boolean;
+    title?: string;
+    description?: string;
+    centerIcon?: (props: IconProps) => ReactNode;
+    centerLabel?: ReactNode;
+    maxValue?: number;
+    color?: DefaultMantineColor;
+    ringSize?: number;
+    thickness?: number;
+    iconSize?: string | number;
+    displayPercent?: 'percent' | 'fraction' | 'none';
+    showPercentAsCenterLabel?: boolean;
+    iconColor?: MantineColor;
+}
+export const RingProgressFieldDefaultProps: Partial<RingProgressFieldProps>;
+export function RingProgressField(props: RingProgressFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface LookupMultiSelectProps extends Omit<MultiSelectProps, 'data'> {
+    parentKeys?: ValuesObject;
+    column: EntityColumn<Value>;
+    formStatus?: OperationStatus<DBStatusResult | DataResult | ValuesObject>;
+    entityForm: UseEntityFormReturnType;
+    entity: Entity<EntityDefinition>;
+    lookupDefName: string;
+    requiredLabel?: string;
+    includeKeyInDescription?: boolean;
+    createLabel?: string;
+    containerProps?: GroupProps;
+    grow?: boolean;
+}
+export const LookupMultiSelectDefaultProps: Partial<LookupMultiSelectProps>;
+export function LookupMultiSelect(props: LookupMultiSelectProps): import("react/jsx-runtime").JSX.Element;
+export interface MenuItem {
+    ID: string;
+    link?: string;
+    label: string;
+    labelComponent?: ReactNode;
+    icon?: ReactNode;
+    description?: string;
+    notifications?: number;
+    subitems?: MenuItem[];
+    rightSection?: ReactElement;
+    noActive?: boolean;
+    loadingComponent?: ReactNode;
+    content?: ReactNode | Promise<ReactNode>;
+    onClick?: () => void;
+    section: 'header' | 'items' | 'footer';
+}
+export interface NavigationState {
+    navigated: boolean;
+    route: string;
+}
+export interface MicroMRouterState {
+    path: string;
+    navigate: (newPath: string) => void;
+    navigationState: NavigationState;
+}
+export const MicroMRouterContext: import("react").Context<MicroMRouterState | undefined>;
+export const useMicroMRouter: () => MicroMRouterState;
+export interface MenuItemsProps {
+    AllItems: MenuItem[];
+    sectionItems: MenuItem[];
+    setContent: Dispatch<SetStateAction<ReactNode>>;
+    setOpened: Dispatch<SetStateAction<boolean>>;
+    clearContent: boolean;
+    activeID: string;
+    subitemActiveID: string;
+    showSubitemIcons?: boolean;
+    defaultLoadingComponent?: ReactNode;
+    onActiveChange: React.Dispatch<SetStateAction<string>>;
+    onSubitemActiveChange: React.Dispatch<SetStateAction<string>>;
+    showItemDescription?: boolean;
+    autoHideNavBarOnClick?: boolean;
+}
+export const MenuItemsPropsDefaultProps: Partial<MenuItemsProps>;
+export function MenuNavLinks(props: MenuItemsProps): import("react/jsx-runtime").JSX.Element;
+export interface MenuProps {
+    items: MenuItem[];
+    setContent: Dispatch<SetStateAction<ReactNode>>;
+    setOpened: Dispatch<SetStateAction<boolean>>;
+    clearContent: boolean;
+    activeIDState: [string, Dispatch<SetStateAction<string>>];
+    subitemActiveIDState: [string, Dispatch<SetStateAction<string>>];
+    showSearch?: boolean;
+    searchLabel?: string;
+    searchIcon?: (props: IconProps) => ReactNode;
+    autoCloseOnItemClickWhenSmallScreen?: boolean;
+}
+export const MenuDefaultProps: Partial<MenuProps>;
+export function MenuNavBar(props: MenuProps): import("react/jsx-runtime").JSX.Element;
+export interface MenuPanelProps {
+    setContent: Dispatch<SetStateAction<ReactNode>>;
+    setOpened: Dispatch<SetStateAction<boolean>>;
+    menuItems: MenuItem[];
+    activeIDState: [string, Dispatch<SetStateAction<string>>];
+    subitemActiveIDState: [string, Dispatch<SetStateAction<string>>];
+    showSearch?: boolean;
+    searchLabel?: string;
+    searchIcon?: (props: IconProps) => ReactNode;
+    autoCloseOnItemClickWhenSmallScreen?: boolean;
+}
+export const MenuPanelDefaultProps: Partial<MenuPanelProps>;
+export function MenuNavBarPanel(props: MenuPanelProps): import("react/jsx-runtime").JSX.Element;
+export interface MenuContentProps {
+    client: MicroMClient;
+    menuId: string;
+    setContent: Dispatch<SetStateAction<ReactNode>>;
+    setOpened: Dispatch<SetStateAction<boolean>>;
+    isLoggedIn: boolean | undefined;
+    setIsLoggedIn: Dispatch<SetStateAction<boolean | undefined>>;
+    loggedInInfo?: Partial<MicroMClientClaimTypes>;
+    theme?: MantineTheme;
+}
+export interface UseMenuContentProps extends MenuContentProps {
+    menuContent: (props: MenuContentProps) => MenuItem[];
+    enableMenuSecurity?: boolean;
+    defaultLoadingComponent?: ReactNode;
+}
+export const UseMenuContentDefaultProps: Partial<UseMenuContentProps>;
+export interface MenuItemActionProps {
+    item: MenuItem;
+    setContent: Dispatch<SetStateAction<ReactNode>>;
+    setOpened: Dispatch<SetStateAction<boolean>>;
+    clearContent: boolean;
+    defaultLoadingComponent?: ReactNode;
+    onActiveChange: React.Dispatch<SetStateAction<string>>;
+    onSubitemActiveChange: React.Dispatch<SetStateAction<string>>;
+    autoHideNavBarOnClick?: boolean;
+}
+export function useMenuContent(props: UseMenuContentProps): {
+    activeIDState: [string, Dispatch<SetStateAction<string>>];
+    subitemActiveIDState: [string, Dispatch<SetStateAction<string>>];
+    items: MenuItem[];
+    actions: SpotlightAction[];
+};
+export interface useAvatarUploaderProps {
+    client: MicroMClient;
+    fileProcessColumn: EntityColumn<string>;
+    fileGUIDColumn: EntityColumn<string>;
+    initialImageURL?: string;
+    labels?: AvatarUploaderLabels;
+    parentFormAPI?: UseEntityFormReturnType;
+}
+export type AvatarUploaderLabels = {
+    modalTitle?: string;
+};
+export const AvatarUploaderDefaultProps: Partial<useAvatarUploaderProps>;
+export interface AvatarUploaderAPI {
+    imageURL?: string;
+    fileID?: string;
+    fileProcessID?: string;
+    fileGUID?: string;
+    handleOpenFileUpload: () => void;
+    handleDeleteFile: (file_id: string, fileGUID: string) => void;
+    parentFormAPI?: UseEntityFormReturnType;
+}
+export function useAvatarUploader(props: useAvatarUploaderProps): AvatarUploaderAPI;
+export interface AvatarUploaderProps extends Omit<AvatarProps, 'src'> {
+    API: AvatarUploaderAPI;
+    PlaceHolderIcon?: React.ReactNode;
+    readOnlyMode?: boolean;
+}
+export function AvatarUploader(props: AvatarUploaderProps): import("react/jsx-runtime").JSX.Element;
+export interface LinkProps {
+    to: string;
+    children: React.ReactNode;
+}
+export function Link(props: LinkProps): import("react/jsx-runtime").JSX.Element;
+export function useNavigation(): MicroMRouterState;
+export function MicroMRouter(props: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export interface RouteProps {
+    path: string;
+    children: React.ReactNode;
+}
+export function Route(props: RouteProps): import("react/jsx-runtime").JSX.Element | null;
+export const DEFAULT_MAP_CENTER: latLng;
+export type GoogleMapsAddressComponentType = 'street_address' | 'route' | 'intersection' | 'political' | 'country' | 'administrative_area_level_1' | 'administrative_area_level_2' | 'administrative_area_level_3' | 'administrative_area_level_4' | 'administrative_area_level_5' | 'administrative_area_level_6' | 'administrative_area_level_7' | 'colloquial_area' | 'locality' | 'sublocality' | 'sublocality_level_1' | 'sublocality_level_2' | 'sublocality_level_3' | 'sublocality_level_4' | 'sublocality_level_5' | 'neighborhood' | 'premise' | 'subpremise' | 'plus_code' | 'postal_code' | 'natural_feature' | 'airport' | 'park' | 'point_of_interest' | 'floor' | 'establishment' | 'landmark' | 'parking' | 'post_box' | 'postal_town' | 'room' | 'street_number' | 'bus_station' | 'train_station' | 'transit_station';
+export type AddressComponentValue = {
+    long_name?: string;
+    short_name?: string;
+};
+export type AddressComponentResult = Partial<Record<GoogleMapsAddressComponentType, AddressComponentValue>>;
+export type MappingAddressType = 'address' | 'postal_code' | 'state_province' | 'city' | 'country' | 'county' | 'unknown';
+export interface MappedAddressResult {
+    street?: string;
+    streetNumber?: string;
+    apartment?: string;
+    floor?: string;
+    country?: string;
+    countryCode?: string;
+    province?: string;
+    provinceCode?: string;
+    city?: string;
+    cityCode?: string;
+    department?: string;
+    departmentCode?: string;
+    postalCode?: string;
+    mappedAddressType?: MappingAddressType;
+}
+export const AddressSearchDefaultZoomLevels: Record<MappingAddressType, number>;
+export type GoogleAddressMappingRecord = Partial<Record<GoogleMapsAddressComponentType, keyof AddressComponentValue>>;
+export type GoogleMapsMappingRules = Partial<Record<keyof Omit<MappedAddressResult, 'mappedAddressType'>, GoogleAddressMappingRecord[]>>;
+export interface AddressMappingRule {
+    conditions: AddressComponentResult;
+    mapping: GoogleMapsMappingRules;
+    dontApplyDefaultMappings?: boolean;
+}
+export type DefaultAddressMappingType = Record<keyof Omit<MappedAddressResult, 'mappedAddressType'>, GoogleAddressMappingRecord[]>;
+export interface GoogleMapsErrorStatus {
+    origin?: string;
+    status?: string;
+}
+export interface PlacesOperationResult {
+    status?: string;
+    result?: google.maps.places.PlaceResult;
+    mapped?: MappedAddressResult;
+}
+export interface GeocodeOperationResult {
+    status?: string;
+    result?: google.maps.GeocoderResult;
+}
+export type MapOptions = google.maps.MapOptions;
+export const GoogleMapsAPILoaderConfig: Partial<LoaderOptions>;
+export function GetGoogleMapsAPILoader(): Loader;
+export function useGooglePlacesAPIloader(): boolean[];
+export function useGoogleGeocoderAPIloader(): boolean[];
+export function useGoogleMapsAPILoader(): boolean[];
+export function useGoogleGeometryAPILoader(): boolean[];
+export function useGoogleMapsAPI(): {
+    mapReady: boolean;
+    placesReady: boolean;
+    geocoderReady: boolean;
+    getAutocompletePredictions: (props: {
+        searchText: string;
+        restrictions?: google.maps.places.ComponentRestrictions;
+        callback: (predictions: google.maps.places.AutocompletePrediction[] | null, status: google.maps.places.PlacesServiceStatus) => void;
+    }) => void;
+    getAutocompleteDetails: (props: {
+        placeId: string;
+        fields: string[] | undefined;
+        callback: (result: google.maps.places.PlaceResult | null, status: google.maps.places.PlacesServiceStatus) => void;
+    }) => void;
+    geocode: (request: google.maps.GeocoderRequest, callback: (results: google.maps.GeocoderResult[] | null | undefined, status: google.maps.GeocoderStatus | null | undefined) => void) => void;
+    attributionsRef: import("react").RefObject<HTMLDivElement>;
+    refreshSessionToken: () => void;
+    geometryReady: boolean;
+    getPlaceDetails: (props: {
+        placeId: string;
+        fields: string[] | undefined;
+    }) => Promise<google.maps.places.PlaceResult>;
+};
+export const DefaultAddressMapping: DefaultAddressMappingType;
+export const ARMappingRules: AddressMappingRule;
+export const UYMappingRules: AddressMappingRule;
+export const USMappingRules: AddressMappingRule;
+export function useGoogleAddressMapping(): {
+    mapGoogleAddressComponents: (addressComponents: google.maps.GeocoderAddressComponent[], mappingRules: AddressMappingRule[]) => MappedAddressResult;
+};
+export function useGoogleAddressAutocomplete({ onAddressFound, restrictions, onChange, value, onAPIError, mappingRules, iconColor }: GoogleAddressAutocompleteProps): {
+    userInputRef: import("react").RefObject<HTMLInputElement>;
+    attributionsRef: import("react").RefObject<HTMLDivElement>;
+    isLoading: boolean;
+    handleOnUserInputChange: (value: string) => void;
+    handleOnItemSubmit: (item: AutocompleteItem & {
+        place_id: string;
+    }) => void;
+    suggestions: (AutocompleteItem & {
+        structuredFormatting: google.maps.places.StructuredFormatting;
+    })[];
+    value: string | undefined;
+    apiError: google.maps.places.PlacesServiceStatus | undefined;
+};
+export interface AddressFoundResult {
+    place: google.maps.places.PlaceResult;
+    address?: MappedAddressResult;
+    suggestionDescription?: string;
+    position?: latLng;
+}
+export type GoogleAddressAutocompleteRestrictions = google.maps.places.ComponentRestrictions;
+export type OnAddressFoundCallback = (result: AddressFoundResult) => void;
+export type OnInputChangeCallback = (value: string) => void;
+export type GoogleAddressAutocompleteProps = Omit<AutocompleteProps, 'data'> & {
+    restrictions?: GoogleAddressAutocompleteRestrictions;
+    onAddressFound?: OnAddressFoundCallback;
+    onAPIError?: (status: google.maps.places.PlacesServiceStatus) => void;
+    mappingRules?: AddressMappingRule[];
+    iconColor?: MantineColor;
+};
+export const DefaultGoogleAddressAutocompleteProps: Partial<GoogleAddressAutocompleteProps>;
+export function GoogleAddressAutocomplete(props: GoogleAddressAutocompleteProps): import("react/jsx-runtime").JSX.Element;
+export interface GoogleMapZoomFeatureStyles {
+    styleDefault?: google.maps.FeatureStyleOptions;
+    styleClicked?: google.maps.FeatureStyleOptions;
+    styleMouseMove?: google.maps.FeatureStyleOptions;
+}
+export const GoogleMapLowZoomStyleDefaultProps: Partial<GoogleMapZoomFeatureStyles>;
+export const GoogleMapMediumZoomStyleDefaultProps: Partial<GoogleMapZoomFeatureStyles>;
+export const GoogleMapHighZoomStyleDefaultProps: Partial<GoogleMapZoomFeatureStyles>;
+export type GoogleMapZoomLevel = 'low' | 'medium' | 'high';
+export interface GoogleMapZoomFeature {
+    featureType: google.maps.FeatureType;
+    zoom: number;
+    styles: GoogleMapZoomFeatureStyles;
+    zoomLevel: GoogleMapZoomLevel;
+}
+export interface GoogleMapZoomFeatureTypeMap {
+    low: GoogleMapZoomFeature;
+    medium: GoogleMapZoomFeature;
+    high: GoogleMapZoomFeature;
+}
+export interface ISelectedRegionData {
+    placeId: string;
+    featureType?: google.maps.FeatureType;
+    countryId?: string;
+    countryName?: string;
+    administrativeAreaLevel1Id?: string;
+    administrativeAreaLevel1Name?: string;
+    administrativeAreaLevel2Id?: string;
+    administrativeAreaLevel2Name?: string;
+    localityId?: string;
+    localityName?: string;
+    postalCode?: string;
+}
+export type SelectedRegionData = ISelectedRegionData & ValuesObject;
+export interface IClickedRegionData {
+    placeId: string;
+    featureType?: google.maps.FeatureType;
+    appliedStyle?: google.maps.FeatureStyleOptions;
+}
+export type ClickedRegionData = IClickedRegionData & ValuesObject;
+export interface GoogleMapRegionSelectorProps {
+    googleMapsAPI: ReturnType<typeof useGoogleMapsAPI>;
+    selectedRegions: Record<string, SelectedRegionData>;
+    setSelectedRegions: Dispatch<SetStateAction<Record<string, SelectedRegionData>>>;
+    clickedRegions: Record<string, ClickedRegionData>;
+    setClickedRegions: Dispatch<SetStateAction<Record<string, ClickedRegionData>>>;
+    featureTypeMap?: GoogleMapZoomFeatureTypeMap;
+    onSelectionChanged?: (selectedRegions: Record<string, SelectedRegionData>) => void;
+    onRegionClicked?: (placeId: string) => void;
+    onRegionMouseMove?: (placeId: string) => void;
+    onAPIError?: (status: GoogleMapsErrorStatus) => void;
+    countries: string[];
+    showOnlyCurrentLayerFeatures?: boolean;
+    mapRestrictions?: google.maps.LatLngBoundsLiteral[];
+    mapCenter?: google.maps.LatLngLiteral;
+    maxRegions?: number;
+    onMaxRegionsReached?: () => void;
+    highlightOnMouseOver?: boolean;
+}
+export const GoogleMapRegionSelectorDefaultProps: Partial<GoogleMapRegionSelectorProps>;
+export const isWithinRestrictions: (latLng: google.maps.LatLngLiteral, boundsRestrictions: google.maps.LatLngBoundsLiteral[]) => boolean;
+export const findClosestCenter: (latLng: google.maps.LatLngLiteral, boundsRestrictions: google.maps.LatLngBoundsLiteral[], defaultCenter: google.maps.LatLngLiteral) => google.maps.LatLngLiteral;
+export const panIfRestricted: (map: google.maps.Map, boundsRestrictions: google.maps.LatLngBoundsLiteral[], defaultCenter: google.maps.LatLngLiteral) => void;
+export interface GoogleMapContextType {
+    map: google.maps.Map | null;
+    renderMarkers: () => React.ReactNode;
+    setInfoWindowContent?: (content: React.ReactNode) => void;
+    infoWindowRef: RefObject<google.maps.InfoWindow>;
+    infoWindowContentRef?: RefObject<HTMLDivElement>;
+}
+export const GoogleMapContext: import("react").Context<GoogleMapContextType | null>;
+export function useGoogleMap(): GoogleMapContextType;
+export function useGoogleMapRegionSelector(props: GoogleMapRegionSelectorProps): {
+    applyStyle: (params: google.maps.FeatureStyleFunctionOptions) => google.maps.FeatureStyleOptions;
+    selectFeature: (features: google.maps.PlaceFeature[]) => void;
+    highLightFeature: (placeIds: string[]) => void;
+    currentZoomFeature: GoogleMapZoomFeature;
+    setCurrentZoomFeature: import("react").Dispatch<import("react").SetStateAction<GoogleMapZoomFeature>>;
+    map: google.maps.Map | null;
+    handleClick: (e: google.maps.FeatureMouseEvent) => void;
+    handleMouseMove: (e: google.maps.FeatureMouseEvent) => void;
+    activeZoomFeatures: GoogleMapZoomFeature[];
+    setActiveZoomFeatures: import("react").Dispatch<import("react").SetStateAction<GoogleMapZoomFeature[]>>;
+    refreshStyles: () => void;
+};
+export function GoogleMapRegionSelector(props: GoogleMapRegionSelectorProps): null;
+export type MarkerOptions = Omit<google.maps.MarkerOptions, "map">;
+export type OnDragEndCallback = (position: google.maps.LatLng) => void;
+export interface MarkerProps {
+    markerOptions: MarkerOptions;
+    onDragEnd?: OnDragEndCallback;
+    onMarkerClick?: (infoWindow: google.maps.InfoWindow) => ReactNode;
+    group?: string;
+    dataSetId?: string;
+    recordIndex?: number;
+    selectedOrder?: number;
+    selectedMarkerOptions?: MarkerOptions;
+    isMapCenter?: boolean;
+}
+export const MarkerPropsDefault: Partial<MarkerProps>;
+export function GoogleMarker(props: MarkerProps): undefined;
+export function useCreateGoogleMap({ mapOptions, children, setInfoWindowContent, infoWindowContentRef }: GoogleMapProps): {
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    mapContext: {
+        map: google.maps.Map | null;
+        renderMarkers: () => import("react").ReactNode;
+        infoWindowRef: import("react").MutableRefObject<google.maps.InfoWindow>;
+        infoWindowContentRef: import("react").RefObject<HTMLDivElement> | undefined;
+        setInfoWindowContent: import("react").Dispatch<import("react").SetStateAction<import("react").ReactNode>> | undefined;
+    };
+};
+export type GoogleMapProps = DefaultProps & PropsWithChildren<{
+    mapOptions: MapOptions;
+    infoWindowContentRef?: RefObject<HTMLDivElement>;
+    setInfoWindowContent?: Dispatch<SetStateAction<ReactNode>>;
+}>;
+export const DefaultMapProps: Partial<GoogleMapProps>;
+export function GoogleMap(props: GoogleMapProps): import("react/jsx-runtime").JSX.Element;
+export function useGoogleAddressMappingRules(): {
+    mappingRules: AddressMappingRule[];
+    addMappingRule: (rules: AddressMappingRule[]) => void;
+    clearMappingRules: () => void;
+};
+export interface InfoWindowPortalProps {
+    container: Element | DocumentFragment;
+    children: React.ReactNode;
+}
+export function InfoWindowPortal({ children, container }: InfoWindowPortalProps): import("react").ReactPortal;
+export interface GoogleMapsInfoWindowProps {
+    container: Element | DocumentFragment;
+    infoWindowContent: React.ReactNode;
+}
+export function GoogleMapsInfoWindow({ container, infoWindowContent }: GoogleMapsInfoWindowProps): import("react/jsx-runtime").JSX.Element;
+export function useDefaultClusterRenderer(groupOfLabel?: string, locationsLabel?: string): {
+    render: (cluster: Cluster, stats: ClusterStats, map: google.maps.Map) => Marker;
+};
+export function useCreateGoogleMapCluster({ mapOptions, InitialMarkerClustererOptions, setInfoWindowContent, infoWindowContentRef, labels, markers, selectedMarkers }: GoogleMapClusterProps): {
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    mapContext: {
+        map: google.maps.Map | null;
+        renderMarkers: () => never;
+        infoWindowRef: import("react").MutableRefObject<google.maps.InfoWindow>;
+        infoWindowContentRef: import("react").RefObject<HTMLDivElement> | undefined;
+        setInfoWindowContent: import("react").Dispatch<import("react").SetStateAction<import("react").ReactNode>> | undefined;
+    };
+};
+export interface MapClusterOptions extends Omit<MarkerClustererOptions, 'map' | 'markers'> {
+}
+export type SelectedMarkerProps = Record<string, Record<number, MarkerProps>>;
+export type GoogleMapClusterProps = DefaultProps & PropsWithChildren<{
+    mapOptions: MapOptions;
+    InitialMarkerClustererOptions?: MapClusterOptions;
+    infoWindowContentRef?: RefObject<HTMLDivElement>;
+    setInfoWindowContent?: Dispatch<SetStateAction<ReactNode>>;
+    markers?: MarkerProps[];
+    labels?: {
+        groupOfLabel?: string;
+        locationsLabel?: string;
+    };
+    selectedMarkers: SelectedMarkerProps;
+}>;
+export const DefaultMapClusterProps: Partial<GoogleMapClusterProps>;
+export function GoogleMapCluster(props: GoogleMapClusterProps): import("react/jsx-runtime").JSX.Element;
+export function getGoogleMapsStreetViewImage(location: google.maps.LatLng | google.maps.LatLngLiteral, width?: number, height?: number, fov?: number): string;
+export interface GoogleMapRegionSelectorMapProps extends GoogleMapProps {
+    regionSelectorProps: Omit<GoogleMapRegionSelectorProps, 'googleMapsAPI'>;
+}
+export function GoogleMapRegionSelectorMap(props: GoogleMapRegionSelectorMapProps): import("react/jsx-runtime").JSX.Element;
+export interface AddressAutocompleteResult {
+    address?: MappedAddressResult;
+    position?: latLng;
+    utcOffsetMinutes?: number;
+    formattedAddress?: string;
+}
+export interface AddressAutocompleteProps extends Omit<GoogleAddressAutocompleteProps, 'restrictions' | 'onAddressFound'> {
+    column: EntityColumn<Value>;
+    entityForm: UseEntityFormReturnType;
+    validate?: ValidatorConfiguration;
+    requiredMessage?: ReactNode;
+    validationContainer?: React.ComponentType<{
+        children: ReactNode;
+    }>;
+    autoFocus?: boolean;
+    countries: string[];
+    onAddressFound?: (addressResult?: AddressAutocompleteResult) => void;
+}
+export function AddressAutocomplete(props: AddressAutocompleteProps): import("react/jsx-runtime").JSX.Element;
+export interface AddressMapMarkerPosition {
+    position: latLng;
+    mappedAddressType?: MappingAddressType;
+}
+export interface AddressMapMarkerProps {
+    initialSearchAddress?: string;
+    readOnly?: boolean;
+    markerPosition?: AddressMapMarkerPosition;
+    defaultMapCenter?: latLng;
+    onMarkerChanged?: (postion: latLng, geocodeOperationResult?: google.maps.GeocoderResult) => void;
+    onAPIError?: (status: GoogleMapsErrorStatus) => void;
+    errorTitle?: string;
+    errorMessage?: string;
+    markerInfoTitle?: string;
+    markerInfoMessage?: string;
+    mapHeight?: MantineNumberSize;
+    showErrors?: boolean;
+    draggable?: boolean;
+    initialMapZoomLevel?: number;
+    fullScreenControl?: boolean;
+}
+export const AddressMapMarkerDefaultProps: Partial<AddressMapMarkerProps>;
+export function AddressMapMarker(props: AddressMapMarkerProps): import("react/jsx-runtime").JSX.Element;
+export interface AddressSearchProps extends Omit<AddressMapMarkerProps, 'showErrors'> {
+    countries: string[];
+    onAddressFound?: (result: AddressFoundResult) => void;
+    mappingRules?: AddressMappingRule[];
+    addressLabel?: string;
+    draggable?: boolean;
+}
+export const AddressSearchDefaultProps: Partial<AddressSearchProps>;
+export function AddressSearch(props: AddressSearchProps): import("react/jsx-runtime").JSX.Element;
+export interface AddressSearchFormProps {
+    helpMessage?: string;
+    okLabel?: string;
+    cancelLabel?: string;
+    countries: string[];
+    initialSearchAddress?: string;
+    currentPosition?: AddressMapMarkerPosition;
+    onCancel?: () => void;
+    onOK: (addressResult?: AddressFoundResult, position?: latLng) => void;
+    mappingRules?: AddressMappingRule[];
+    draggable?: boolean;
+}
+export const AddressSearchFormDefaultProps: Partial<AddressSearchFormProps>;
+export function AddressSearchForm(props: AddressSearchFormProps): import("react/jsx-runtime").JSX.Element;
+export interface AddressSearchModalOptions {
+    onOK: (address?: AddressFoundResult, position?: latLng) => void;
+    onCancel?: () => void;
+    onClosed?: () => void;
+    modalProps?: ModalSettings;
+    search?: string;
+    helpMessage?: string;
+    title?: string;
+    countries: string[];
+    currentPosition?: AddressMapMarkerPosition;
+    mappingRules?: AddressMappingRule[];
+}
+export const UseAddressSearchFormDefaultProps: Partial<AddressSearchModalOptions>;
+export function useAddressSearchForm(): (props: AddressSearchModalOptions) => Promise<void>;
+export interface AddressLookupProps extends Omit<AddressAutocompleteProps, 'rightSection'> {
+    icon?: React.ReactNode;
+    iconLabel?: string;
+    iconVariant?: ActionIconVariant;
+    currentPosition?: AddressMapMarkerPosition;
+}
+export const AddressLookupDefaultProps: Partial<AddressLookupProps>;
+export function AddressLookup(props: AddressLookupProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Converts a hexadecimal color string to an RGB array.
+ * @param hex - The hexadecimal color string.
+ * @returns The RGB array.
+ */
+export function hexToRgb(hex: string): [number, number, number];
+/**
+ * Converts an RGB array to a hexadecimal color string.
+ * @param r - The red component.
+ * @param g - The green component.
+ * @param b - The blue component.
+ * @returns The hexadecimal color string.
+ */
+export function rgbToHex(r: number, g: number, b: number): string;
+/**
+ * Interpolates between two colors.
+ * @param color1 - The first color.
+ * @param color2 - The second color.
+ * @param factor - The interpolation factor.
+ * @returns The interpolated color.
+ */
+export function interpolateColor(color1: string, color2: string, factor: number): string;
+/**
+ * Computes a hash and converts a string to a color. Use this function to generate a color from a string from a small set of strings.
+ * @param str - The string to convert.
+ * @returns The color.
+ */
+export function stringToColor(str: string): string;
+/**
+ * Computes a label color (either white or black) based on the background color generated by stringToColor.
+ * @param str - The string to convert to a color and use as background.
+ * @returns The label color.
+ */
+export function stringToColorLabel(str: string): string;
+export const MarkerSVGConverterFillColorTAG = "{FILL_COLOR}";
+export const MarkerSVGConverterStrokeColorTAG = "{STROKE_COLOR}";
+export const MarkerSVGConverterFillOpacityTAG = "{FILL_OPACITY}";
+export const MarkerSVGConverterStyleTAG = "{STYLES}";
+export const MarkerSVGConverterSelectedStyleTAG = "{SELECTED_STYLE}";
+/**
+ * Hook that returns a function to convert a SVG image to a URL with the specified colors.
+ * it replaces the tags {FILL_COLOR}, {STROKE_COLOR} and {FILL_OPACITY} with the specified colors.
+ * @returns
+ */
+export function useGoogleMarkerSVGConvertToURL(): (svgImage: string, fillColor?: string, strokeColor?: string, fillOpacity?: number, styles?: string, selectedStyle?: string) => {
+    icon: string;
+    url?: string;
+};
+export const MapMarkerDefaultShadowStyle = "-webkit-filter: drop-shadow( 3px 3px 2px rgba(0, 0, 0, .7)); filter: drop-shadow( 3px 3px 2px rgba(0, 0, 0, .7));";
+export const MapMarkerDefaultSelectedStyle = "-webkit-filter: drop-shadow(0px 0px 3px rgba(0, 0, 0, .8)); filter: drop-shadow(0px 0px 3px rgba(0, 0, 0, .8));";
+export const MapMarkerCircleFilledSVGIcon = "<svg  xmlns=\"http://www.w3.org/2000/svg\" style=\"{STYLES}{SELECTED_STYLE}\" width=\"24\"  height=\"24\"  viewBox=\"0 0 24 24\"  fill=\"{FILL_COLOR}\"  class=\"icon icon-tabler icons-tabler-filled icon-tabler-circle\"><path stroke=\"none\" d=\"M0 0h24v24H0z\" fill=\"none\"/><path d=\"M7 3.34a10 10 0 1 1 -4.995 8.984l-.005 -.324l.005 -.324a10 10 0 0 1 4.995 -8.336z\" /></svg>";
+export const MapMarkerCircleCheckedSVGIcon = "<svg  xmlns=\"http://www.w3.org/2000/svg\" style=\"{STYLES}{SELECTED_STYLE}\" width=\"24\"  height=\"24\"  viewBox=\"0 0 24 24\"  fill=\"{FILL_COLOR}\"  class=\"icon icon-tabler icons-tabler-filled icon-tabler-circle-check\"><path stroke=\"none\" d=\"M0 0h24v24H0z\" fill=\"none\"/><path d=\"M17 3.34a10 10 0 1 1 -14.995 8.984l-.005 -.324l.005 -.324a10 10 0 0 1 14.995 -8.336zm-1.293 5.953a1 1 0 0 0 -1.32 -.083l-.094 .083l-3.293 3.292l-1.293 -1.292l-.094 -.083a1 1 0 0 0 -1.403 1.403l.083 .094l2 2l.094 .083a1 1 0 0 0 1.226 0l.094 -.083l4 -4l.083 -.094a1 1 0 0 0 -.083 -1.32z\" /></svg>";
+export const MapMarkerDefaultSelectedSVGIcon = "<svg  xmlns=\"http://www.w3.org/2000/svg\" style=\"{STYLES}{SELECTED_STYLE}\" width=\"24\"  height=\"24\"  viewBox=\"0 0 24 24\"  fill=\"{FILL_COLOR}\"  class=\"icon icon-tabler icons-tabler-filled icon-tabler-circle\"><path stroke=\"none\" d=\"M0 0h24v24H0z\" fill=\"none\"/><path d=\"M7 3.34a10 10 0 1 1 -4.995 8.984l-.005 -.324l.005 -.324a10 10 0 0 1 4.995 -8.336z\" /></svg>";
+export const MapMarkerDefaultSVGIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"{STYLES}{SELECTED_STYLE}\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"{FILL_COLOR}\" fill-opacity=\"{FILL_OPACITY}\" class=\"icon icon-tabler icons-tabler-filled icon-tabler-map-pin\"><path stroke=\"none\" d=\"M0 0h24v24H0z\" fill=\"none\"/><path d=\"M18.364 4.636a9 9 0 0 1 .203 12.519l-.203 .21l-4.243 4.242a3 3 0 0 1 -4.097 .135l-.144 -.135l-4.244 -4.243a9 9 0 0 1 12.728 -12.728zm-6.364 3.364a3 3 0 1 0 0 6a3 3 0 0 0 0 -6z\" /></svg>";
+export const MapMarkerDefaultFillColor = "#1e72c1";
+export const MapMarkerDefaultFillOpacity = 0.7;
+export const MapMarkerGroupDefaultSVGIcon = "<svg  xmlns=\"http://www.w3.org/2000/svg\" style=\"{STYLES}{SELECTED_STYLE}\" width=\"24\"  height=\"24\"  viewBox=\"0 0 24 24\" fill=\"{FILL_COLOR}\" fill-opacity=\"{FILL_OPACITY}\" class=\"icon icon-tabler icons-tabler-filled icon-tabler-hexagon\"><path stroke=\"none\" d=\"M0 0h24v24H0z\" fill=\"none\"/><path d=\"M10.425 1.414l-6.775 3.996a3.21 3.21 0 0 0 -1.65 2.807v7.285a3.226 3.226 0 0 0 1.678 2.826l6.695 4.237c1.034 .57 2.22 .57 3.2 .032l6.804 -4.302c.98 -.537 1.623 -1.618 1.623 -2.793v-7.284l-.005 -.204a3.223 3.223 0 0 0 -1.284 -2.39l-.107 -.075l-.007 -.007a1.074 1.074 0 0 0 -.181 -.133l-6.776 -3.995a3.33 3.33 0 0 0 -3.216 0z\" /></svg>";
+export const MapMarkerGroupDefaultFillColor = "red";
+export const MapMarkerGroupDefaultLabelOrigin: {
+    x: number;
+    y: number;
+};
+export interface UseCreateMarkerOptionsProps {
+    svgIcon?: string;
+    fillColor?: string;
+    strokeColor?: string;
+    fillOpacity?: number;
+    styles?: string;
+    selectedSvgIcon?: string;
+    selectedFillColor?: string;
+    selectedStrokeColor?: string;
+    selectedFillOpacity?: number;
+    selectedStyles?: string;
+    selectedLabelOrigin?: google.maps.Point;
+    selectedLabel?: google.maps.MarkerLabel;
+    position: google.maps.LatLng | google.maps.LatLngLiteral;
+    assignColorByValue?: string;
+    title?: string;
+    dataSetId?: string;
+    recordIndex?: number;
+    labelOrigin?: google.maps.Point;
+    label?: google.maps.MarkerLabel;
+    isMapCenter?: boolean;
+}
+export function useCreateMarkerOptions(): (props: UseCreateMarkerOptionsProps) => {
+    markerOptions: google.maps.MarkerOptions;
+    selectedMarkerOptions: google.maps.MarkerOptions;
+    isMapCenter: boolean | undefined;
+};
+export type GroupRecord = {
+    recordIndex: number;
+    recordValue: ValuesRecord;
+};
+export interface LocationGroup {
+    locationKey: string;
+    location: google.maps.LatLng | google.maps.LatLngLiteral;
+    records: GroupRecord[];
+}
+export interface RecordGroupManager {
+    locationGroups: RefObject<LocationGroup[]>;
+    getGroupByLocation: (location: google.maps.LatLng | google.maps.LatLngLiteral) => LocationGroup | undefined;
+    addRecordToGroup: (location: google.maps.LatLng | google.maps.LatLngLiteral, recordIndex: number, recordValue: ValuesRecord) => LocationGroup;
+    clearAllGroups: () => void;
+    clearOneRecordGroups: () => void;
+}
+export function useRecordGroupManager(): RecordGroupManager;
+export interface DataMapMarkerProps extends UseCreateMarkerOptionsProps {
+}
+export interface DataMapSVGIcon {
+    svgIcon: string;
+    svgSelectedIcon?: string;
+}
+export type DataMapInfoWindowRenderer = (record: ValuesRecord, position: latLng, groupManager: RecordGroupManager, infoWindow: google.maps.InfoWindow, UIAPI: ReturnType<typeof useEntityUI>, theme: MantineTheme, entity: Entity<EntityDefinition>, modal: ModalContextType) => ReactNode;
+export type DataMapSelectRecordsRenderer = (record: ValuesRecord, recordIndex: number, position: latLng, groupManager: RecordGroupManager, infoWindow: google.maps.InfoWindow, UIAPI: ReturnType<typeof useEntityUI>, theme: MantineTheme, entity: Entity<EntityDefinition>) => ReactNode | null;
+export type DataMapMarkerRenderer = (record: ValuesRecord, position: latLng, theme: MantineTheme) => DataMapMarkerProps | null;
+export type DataMapGroupMarkerRenderer = (group: LocationGroup, markerOptions: DataMapMarkerProps, theme: MantineTheme) => DataMapMarkerProps | null;
+export interface DataMapProps {
+    dataGridProps: Omit<DataGridProps, 'gridHeight'>;
+    latitudRecordIndex: number;
+    longitudRecordIndex: number;
+    mapStyle?: google.maps.MapTypeStyle[];
+    mapOptions?: google.maps.MapOptions;
+    markerClustererOptions?: MapClusterOptions;
+    markerRenderer?: DataMapMarkerRenderer;
+    groupMarkerRenderer?: DataMapGroupMarkerRenderer;
+    InfoWindowRenderer?: DataMapInfoWindowRenderer;
+    selectRecordsRenderer?: DataMapSelectRecordsRenderer;
+    labels?: {
+        gridTabLabel?: string;
+        mapTabLabel?: string;
+    };
+    mapHeight?: string | number;
+    centerMarker?: DataMapMarkerProps;
+    onDataRefresh?: () => void;
+}
+export const DataMapDefaultProps: Partial<DataMapProps>;
+export const DataMapDefaultDataGridProps: Partial<DataGridProps>;
+export function DataMap(props: DataMapProps): import("react/jsx-runtime").JSX.Element;
+export interface DataMapPageProps extends Omit<DataMapProps, 'dataGridProps'> {
+    dataGridProps: Omit<DataGridProps, 'gridHeight' | 'entity'>;
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    client: MicroMClient;
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+    showTitle?: boolean;
+}
+export const DataMapPageDefaultProps: Partial<DataMapPageProps>;
+export function DataMapPage(props: DataMapPageProps): import("react/jsx-runtime").JSX.Element;
+export interface DataMapFormProps extends DataMapProps {
+    customTitle?: ReactNode;
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    showTitle?: boolean;
+}
+export const DataMapFormDefaultProps: Partial<DataMapFormProps>;
+export function DataMapForm(props: DataMapFormProps): import("react/jsx-runtime").JSX.Element;
+export interface UseMultiDataMapGridProps {
+    dataMapView: MultiDataMapViewProps;
+    viewState: ReturnType<typeof useViewState>;
+    selectionMode?: GridSelectionMode;
+    mapReady: boolean;
+    placesReady: boolean;
+    geocoderReady: boolean;
+    clearSelectionOnActionExecuted?: boolean;
+}
+export function useMultiDataMapGrid({ dataMapView, viewState, selectionMode, mapReady, placesReady, geocoderReady, clearSelectionOnActionExecuted }: UseMultiDataMapGridProps): {
+    dgProps: {
+        onActionExecuted: (actionName: string, result?: boolean) => void;
+        selectionMode: GridSelectionMode;
+        latitudRecordIndex?: number;
+        longitudRecordIndex?: number;
+        dataSetId?: string;
+        tabLabel?: string;
+        tabIcon?: (props: import("@tabler/icons-react").IconProps) => import("react").ReactNode;
+        InfoWindowRenderer?: import("src").DataMapInfoWindowRenderer;
+        selectRecordsRenderer?: import("src").DataMapSelectRecordsRenderer;
+        markerRenderer?: import("src").DataMapMarkerRenderer;
+        groupMarkerRenderer?: import("src").DataMapGroupMarkerRenderer;
+        centerMarkerColumnIndex?: number;
+        search: string[];
+        entity: import("src").Entity<import("src").EntityDefinition>;
+        formMode: "view" | "add" | "edit" | undefined;
+        onModalClosed: (cancelled?: boolean) => void;
+        onModalSaved: (new_status: import("src").OperationStatus<import("src").DBStatusResult | null>) => void;
+        modalFormSize: string | number | undefined;
+        onModalCancelled: () => void;
+        parentKeys: import("src").ValuesObject;
+        withBorder: boolean;
+        renderOnlyWhenVisible: boolean;
+        viewName: string;
+        refreshOnInit: boolean;
+        limit: "0" | "10000" | "50" | "100" | "500" | "1000" | undefined;
+        enableAdd: boolean;
+        enableEdit: boolean;
+        enableView: boolean;
+        enableDelete: boolean;
+        saveFormBeforeAdd: boolean;
+        autoSelectFirstRow: boolean;
+        labels: import("src").DataGridLabels;
+        onRecordsDeleted: () => void;
+        onActionRefreshOnClose: () => void;
+        onAddClick: (gridAddClick: (element?: HTMLElement) => void, element?: HTMLElement) => void;
+        onEditClick: (keys: import("src").ValuesObject, element?: HTMLElement) => void;
+        onDeleteClick: (keys: import("src").ValuesObject[], element?: HTMLElement) => void;
+        columnsOverrides: import("src").GridColumnsOverrides;
+        autoSizeColumnsOnLoad: boolean;
+        preserveSelection: boolean;
+        onSelectionChanged: import("src").DataGridSelectionChangedCallback;
+        columnBorders: boolean;
+        rowBorders: boolean;
+        visibleFilters: string[];
+        enableImport: boolean;
+        showActions: boolean;
+        actionsButtonVariant: "white" | "filled" | "outline" | "light" | "default" | "gradient" | "subtle" | undefined;
+        allwaysRefreshOnEntityClose: boolean;
+        onDataRefresh: (result: import("src").OperationStatus<import("src").DataResult[]>) => void;
+        doubleClickAction: (("view" | "none" | "edit" | ((record: import("src").GridRecord) => void)) & NonNullable<"view" | "none" | "edit" | ((record: import("src").GridRecord) => void) | undefined>) | undefined;
+        setInitialFiltersFromColumns: boolean;
+        showToolbar: boolean;
+        showActionsToolbar: boolean;
+    };
+    viewState: {
+        searchText: string[] | undefined;
+        setSearchText: import("react").Dispatch<import("react").SetStateAction<string[] | undefined>>;
+        limitRows: string | null;
+        setLimitRows: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        refresh: boolean;
+        setRefresh: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        filterValues: import("src").ValuesObject | undefined;
+        setFilterValues: import("react").Dispatch<import("react").SetStateAction<import("src").ValuesObject | undefined>>;
+        filtersDescription: import("src").ValuesObject | undefined;
+        setFiltersDescription: import("react").Dispatch<import("react").SetStateAction<import("src").ValuesObject | undefined>>;
+    };
+    executeViewState: import("src").OperationStatus<import("src").DataResult[]>;
+    dataGridAPI: {
+        handleSelectionChanged: import("src").GridSelectionChangedCallback;
+        handleDoubleClick: import("src").GridDoubleClickCallback;
+        handleDeleteClick: (element?: HTMLElement) => Promise<void>;
+        handleEditClick: (element?: HTMLElement) => Promise<void>;
+        handleAddClick: (element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+        handleViewClick: (element?: HTMLElement) => Promise<void>;
+        handleToggleSelectable: () => void;
+        handleRefresh: (search_text: string[] | undefined) => void;
+        handleExecuteAction: (action: import("src").EntityClientAction, element?: HTMLElement) => Promise<void>;
+        handleExport: () => Promise<void>;
+        selectedRowsCount: number;
+        showSelectCheckbox: boolean;
+        UIAPI: {
+            handleAddClick: (element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+            handleEditClick: (keys: import("src").ValuesObject, element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+            handleViewClick: (keys: import("src").ValuesObject, element?: HTMLElement, onClosed?: (cancelled?: boolean) => void) => Promise<void>;
+            handleDeleteClick: (keys: import("src").ValuesObject[], element?: HTMLElement) => Promise<void>;
+            handleExecuteAction: (action: import("src").EntityClientAction, keys: import("src").ValuesObject[], element?: HTMLElement) => Promise<boolean | undefined>;
+            handleDeleteRecord: (keys: import("src").ValuesObject, element?: HTMLElement) => Promise<void>;
+            handleImportDataClick: () => Promise<void>;
+        };
+        columns: import("src").GridColumn[] | undefined;
+        rows: ValuesRecord[] | undefined;
+        isLoading: boolean;
+        handleImportDataClick: () => Promise<void>;
+    };
+    actualColumnsOverrides: import("src").GridColumnsOverrides | undefined;
+    actualSelectionClickHandler: import("src").DataMapSelectRecordsRenderer;
+    selectedRows: GridSelection;
+    setSelectedRows: import("react").Dispatch<import("react").SetStateAction<GridSelection>>;
+    getInfoWindowClickHandler: (dataSetId: string, record: ValuesRecord, recordIndex: number) => ((infoWindow: google.maps.InfoWindow) => import("react").ReactNode) | null;
+    markers: MarkerProps[];
+    selectedMarkers: SelectedMarkerProps;
+    showOnMap: boolean;
+    setShowOnMap: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    centerMarker: MarkerProps | undefined;
+};
+export interface MultiDataMapViewProps extends Omit<DataGridProps, 'gridHeight' | 'selectionMode' | 'enableExport' | 'autoFocus' | 'toolbarIconVariant' | 'toolbarSize' | 'filtersFormSize' | 'parentFormAPI'> {
+    latitudRecordIndex?: number;
+    longitudRecordIndex?: number;
+    dataSetId?: string;
+    tabLabel?: string;
+    tabIcon?: (props: IconProps) => ReactNode;
+    InfoWindowRenderer?: DataMapInfoWindowRenderer;
+    selectRecordsRenderer?: DataMapSelectRecordsRenderer;
+    markerRenderer?: DataMapMarkerRenderer;
+    groupMarkerRenderer?: DataMapGroupMarkerRenderer;
+    centerMarkerColumnIndex?: number;
+}
+export interface MultiDataMapProps {
+    dataMapView1: MultiDataMapViewProps;
+    dataMapView2?: MultiDataMapViewProps;
+    dataMapView3?: MultiDataMapViewProps;
+    dataMapView4?: MultiDataMapViewProps;
+    dataMapView5?: MultiDataMapViewProps;
+    search?: string[];
+    limit?: DataViewLimit;
+    enableExport?: boolean;
+    autoFocus?: boolean;
+    toolbarIconVariant?: ActionIconVariant;
+    toolbarSize?: DataGridToolbarSizes;
+    filtersFormSize?: MantineNumberSize;
+    selectionMode?: GridSelectionMode;
+    mapStyle?: google.maps.MapTypeStyle[];
+    mapOptions?: google.maps.MapOptions;
+    markerClustererOptions?: MapClusterOptions;
+    labels?: {
+        mapTabLabel?: string;
+    };
+    mapHeight?: string | number;
+    centerMarker?: DataMapMarkerProps;
+    onDataRefresh?: () => void;
+    clearSelectionOnActionExecuted?: boolean;
+    formMode?: FormMode;
+}
+export const MultiDataMapDefaultProps: Partial<MultiDataMapProps>;
+export function MultiDataMap(props: MultiDataMapProps): import("react/jsx-runtime").JSX.Element;
+export interface MultiDataMapPageViewProps extends Omit<MultiDataMapViewProps, 'entity'> {
+    entityConstructor: (client: MicroMClient) => Entity<EntityDefinition>;
+}
+export interface MultiDataMapPageProps extends Omit<MultiDataMapProps, 'dataMapView1' | 'dataMapView2' | 'dataMapView3' | 'dataMapView4' | 'dataMapView5'> {
+    dataMapView1: MultiDataMapPageViewProps;
+    dataMapView2?: MultiDataMapPageViewProps;
+    dataMapView3?: MultiDataMapPageViewProps;
+    dataMapView4?: MultiDataMapPageViewProps;
+    dataMapView5?: MultiDataMapPageViewProps;
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    client: MicroMClient;
+    showTitle?: boolean;
+}
+export const MultiDataMapPageDefaultProps: Partial<MultiDataMapPageProps>;
+export function MultiDataMapPage(props: MultiDataMapPageProps): import("react/jsx-runtime").JSX.Element;
+export interface MultiDataMapFormProps extends MultiDataMapProps {
+    customTitle?: ReactNode;
+    title?: string;
+    icon?: ReactNode;
+    helpText?: string;
+    formMode: FormMode;
+    showTitle?: boolean;
+}
+export const MultiDataMapFormDefaultProps: Partial<MultiDataMapFormProps>;
+export function MultiDataMapForm(props: MultiDataMapFormProps): import("react/jsx-runtime").JSX.Element;
+export interface RegionSelectorItemProps extends Omit<BadgeProps, 'rightSection'> {
+    onCloseClick?: () => void;
+}
+export function RegionSelectorItem({ onCloseClick, children, ...rest }: RegionSelectorItemProps): import("react/jsx-runtime").JSX.Element;
+export interface RegionSelectorProps extends Omit<GoogleMapRegionSelectorProps, 'googleMapsAPI'> {
+    mapId: string;
+    readOnly?: boolean;
+    mapRestrictions?: google.maps.LatLngBoundsLiteral[];
+    defaultMapCenter?: latLng;
+    onAPIError?: (status: GoogleMapsErrorStatus) => void;
+    errorTitle?: string;
+    errorMessage?: string;
+    mapHeight?: MantineNumberSize;
+    showErrors?: boolean;
+    searchLabel?: string;
+    loadingLabel?: string;
+    unknownStateLabel?: string;
+    regionListMode?: 'count' | 'names';
+    suppressCountyString?: string;
+    searchDescriptionLabel?: string;
+    mapHelpLabel?: string;
+    selectedRegionsLabel?: string;
+    autoFocus?: boolean;
+}
+export const RegionSelectorDefaultProps: Partial<RegionSelectorProps>;
+export function RegionSelector(props: RegionSelectorProps): import("react/jsx-runtime").JSX.Element;
+export interface DataRegionSelectorProps extends RegionSelectorProps {
+    entity: Entity<EntityDefinition>;
+    queryName: string;
+    parentKeys?: ValuesObject;
+    mapDataResult: (data: DataResult) => Record<string, SelectedRegionData>;
+}
+export function DataRegion(props: DataRegionSelectorProps): import("react/jsx-runtime").JSX.Element;
+export interface MicroMError extends Error {
+    status: number;
+    message: string;
+    statusMessage?: string;
+    url?: string;
+}
+export const toMicroMError: (e: any) => MicroMError;
+export const toDBStatusMicroMError: (dbstat: DBStatus[], form_mode?: FormMode) => MicroMError;
+export enum EndpointAccess {
+    None = 0,
+    Create = 1,
+    Update = 2,
+    Delete = 4,
+    Get = 8,
+    Lookup = 16,
+    Execute = 32
+}
+export interface PublicEndpoint {
+    EntityName: string;
+    AllowedAccess: EndpointAccess;
+    AllowedProcs?: Set<string>;
+    AllowedActions?: Set<string>;
+}
+export interface TokenStorage {
+    saveToken(app_id: string, token: MicroMToken): Promise<void>;
+    readToken(app_id: string): Promise<MicroMToken | null>;
+    deleteToken(app_id: string): Promise<void>;
+}
+export class TokenWebStorage implements TokenStorage {
+    #private;
+    constructor(storage_type?: 'sessionStorage' | 'localStorage', storage_name?: string);
+    saveToken(app_id: string, token: MicroMToken): Promise<void>;
+    readToken(app_id: string): Promise<MicroMToken | null>;
+    deleteToken(app_id: string): Promise<void>;
+}
+export type APIAction = "get" | "insert" | "update" | "delete" | "lookup" | "view" | "action" | "upload" | "proc" | "process" | "import";
+export interface FileUploadResponse {
+    ErrorMessage?: string;
+    FileProcessId?: string;
+    FileId?: string;
+    FileGuid?: string;
+    documentURL?: string;
+    thumbnailURL?: string;
+}
+export type FetchUploadProgress = (file: File, progress: number) => void;
+export interface MicroMClientProps {
+    api_url: string;
+    app_id: string;
+    login_timeout?: number;
+    mode?: RequestMode;
+    tokenStorage?: TokenStorage;
+    publicEndpoints?: Record<string, PublicEndpoint>;
+    dataStorage?: DataStorage;
+    redirect_on_401?: string;
+}
+export class MicroMClient {
+    #private;
+    constructor({ api_url, app_id, login_timeout, mode, tokenStorage, publicEndpoints, dataStorage, redirect_on_401 }: MicroMClientProps);
+    getAPPID(): string;
+    startRecordPaths(): void;
+    stopRecordPaths(): void;
+    localLogoff(): Promise<void>;
+    logoff(): Promise<void>;
+    isLoggedIn(): Promise<boolean>;
+    isLoggedInLocal(): Promise<boolean>;
+    get LOGGED_IN_USER(): Partial<MicroMClientClaimTypes> | undefined;
+    updateClientClaims(claims: Partial<MicroMClientClaimTypes>): Promise<void>;
+    login(username: string, password: string, rememberme?: boolean): Promise<MicroMToken | undefined>;
+    recoveryemail(username: string): Promise<DBStatusResult>;
+    recoverpassword(username: string, password: string, recoverycode: string): Promise<DBStatusResult>;
+    getMenus(): Promise<Set<string>>;
+    getRememberUser(): Promise<string | null>;
+    downloadBlob(fileUrl: string, abort_signal?: AbortSignal | null): Promise<Blob>;
+    get(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, abort_signal?: AbortSignal | null): Promise<ValuesObject>;
+    insert(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, recordsSelection: ValuesObject[] | null, abort_signal?: AbortSignal | null): Promise<DBStatusResult>;
+    update(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, recordsSelection: ValuesObject[] | null, abort_signal?: AbortSignal | null): Promise<DBStatusResult>;
+    delete(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject | null, recordsSelection: ValuesObject[] | null, abort_signal?: AbortSignal | null): Promise<DBStatusResult>;
+    lookup(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, lookup_name?: string | null, abort_signal?: AbortSignal | null): Promise<any>;
+    view(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, view_name: string, abort_signal?: AbortSignal | null): Promise<DataResult[]>;
+    proc(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, recordsSelection: ValuesObject[] | null, proc_name: string, abort_signal?: AbortSignal | null): Promise<DataResult[]>;
+    process(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, recordsSelection: ValuesObject[] | null, proc_name: string, abort_signal?: AbortSignal | null): Promise<DBStatusResult>;
+    action<TReturn>(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, action_name: string, abort_signal?: AbortSignal | null): Promise<TReturn>;
+    import(entity_name: string, parent_keys: ValuesObject | null, values: ValuesObject, import_procname: string | null, abort_signal?: AbortSignal | null): Promise<ImpDataResult>;
+    upload(file: File, fileprocess_id: string, abort_signal?: AbortSignal | null, max_size?: number, quality?: number, onProgress?: FetchUploadProgress): Promise<FileUploadResponse>;
+    getDocumentURL(fileGuid: string): string;
+    getThumbnailURL(fileGuid: string, max_size?: number, quality?: number): string;
+}
+export class RecordReader {
+    constructor(dataResult: DataResult);
+    getValue(recordIndex: number, headerName: string): Value | undefined;
+}
+
+//# sourceMappingURL=index.d.ts.map