@morghulis/core 1.0.26 → 1.0.27

package/dist/types/data/upload/components/impoter/UploadImporter.vue.d.ts

@@ -1,5 +1,5 @@
-import type { MetaField } from "@morghulis/lib";
 import type { UploadParam } from "../../types";
+import { MetaField } from "../../../../lib";
 type __VLS_Props = {
     fields: MetaField[];
     param: UploadParam;

package/dist/types/data/upload/components/impoter/components/ImporterTemplate.vue.d.ts

@@ -1,4 +1,4 @@
-import { type MetaField } from "@morghulis/lib";
+import { MetaField } from "../../../../../lib";
 type __VLS_Props = {
     fields: MetaField[];
 };

package/dist/types/data/upload/components/table/UploadTable.vue.d.ts

@@ -1,4 +1,4 @@
-import { type MetaField, type MetaRow } from "@morghulis/lib";
+import { type MetaField, type MetaRow } from "../../../../lib";
 type __VLS_Props = {
     fields: MetaField[];
     rows: MetaRow[];

package/dist/types/data/upload/components/table/components/cells/UploadTableCell.vue.d.ts

@@ -1,4 +1,4 @@
-import type { MetaField, MetaRow } from "@morghulis/lib";
+import { MetaField, type MetaRow } from "../../../../../../lib";
 type __VLS_Props = {
     field: MetaField;
     row: MetaRow;

package/dist/types/data/upload/components/table/components/valid/UploadTableValidation.vue.d.ts

@@ -1,4 +1,4 @@
-import type { MetaRow } from "@morghulis/lib";
+import type { MetaRow } from "../../../../../../lib";
 type __VLS_Props = {
     row: MetaRow;
 };

package/dist/types/data/upload/hooks.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 import type { UploadFrame, UploadParam, UploadProps } from "./types";
-import { type DataItem, MetaField, type MetaRow, MetaView } from "@morghulis/lib";
+import { type DataItem, MetaField, type MetaRow, MetaView } from "../../lib";
 export declare function useUpload($config: UploadProps | Ref<UploadProps>): {
     loading: Ref<boolean, boolean>;
     setArray: (items: DataItem[]) => void;
@@ -19,12 +19,12 @@ export declare function useUpload($config: UploadProps | Ref<UploadProps>): {
     fields: import("vue").ComputedRef<MetaField[]>;
     rows: Ref<{
         $index: number;
-        key: import("@morghulis/lib").DataItemId;
-        cells: Record<string, import("@morghulis/lib").MetaCell>;
+        key: import("../../lib").DataItemId;
+        cells: Record<string, import("../../lib").MetaCell>;
         item: {
             [x: string]: any;
-            id?: import("@morghulis/lib").DataItemId | undefined;
-            sort?: import("@morghulis/lib").DataItemId | undefined;
+            id?: import("../../lib").DataItemId | undefined;
+            sort?: import("../../lib").DataItemId | undefined;
             saved?: boolean | undefined;
             name?: string | undefined;
             disabled?: boolean | undefined;
@@ -34,12 +34,12 @@ export declare function useUpload($config: UploadProps | Ref<UploadProps>): {
         message?: string | null | undefined;
     }[], MetaRow[] | {
         $index: number;
-        key: import("@morghulis/lib").DataItemId;
-        cells: Record<string, import("@morghulis/lib").MetaCell>;
+        key: import("../../lib").DataItemId;
+        cells: Record<string, import("../../lib").MetaCell>;
         item: {
             [x: string]: any;
-            id?: import("@morghulis/lib").DataItemId | undefined;
-            sort?: import("@morghulis/lib").DataItemId | undefined;
+            id?: import("../../lib").DataItemId | undefined;
+            sort?: import("../../lib").DataItemId | undefined;
             saved?: boolean | undefined;
             name?: string | undefined;
             disabled?: boolean | undefined;
@@ -51,15 +51,15 @@ export declare function useUpload($config: UploadProps | Ref<UploadProps>): {
     results: import("vue").ComputedRef<any[]>;
     array: Ref<{
         [x: string]: any;
-        id?: import("@morghulis/lib").DataItemId | undefined;
-        sort?: import("@morghulis/lib").DataItemId | undefined;
+        id?: import("../../lib").DataItemId | undefined;
+        sort?: import("../../lib").DataItemId | undefined;
         saved?: boolean | undefined;
         name?: string | undefined;
         disabled?: boolean | undefined;
     }[], DataItem[] | {
         [x: string]: any;
-        id?: import("@morghulis/lib").DataItemId | undefined;
-        sort?: import("@morghulis/lib").DataItemId | undefined;
+        id?: import("../../lib").DataItemId | undefined;
+        sort?: import("../../lib").DataItemId | undefined;
         saved?: boolean | undefined;
         name?: string | undefined;
         disabled?: boolean | undefined;

package/dist/types/data/upload/types.d.ts

@@ -1,4 +1,4 @@
-import type { MetaValidator, MetaView, PropItem } from "@morghulis/lib";
+import type { MetaValidator, MetaView, PropItem } from "../../lib";
 export type UploadProps = {
     view: MetaView;
     validator?: MetaValidator;

package/dist/types/index.d.ts

@@ -29,5 +29,4 @@ declare const createMorghulis: (options?: Options) => {
     install(Vue: App): void;
 };
 export { createMorghulis };
-export * from '@morghulis/lib';
 export * from './components';

package/dist/types/lib/core/channel/hooks.d.ts

@@ -0,0 +1,11 @@
+import type { Channel, ChannelConfig } from "./types";
+import { type Ref } from "vue";
+export declare function useChannelContainer(): {
+    container: import("vue").Reactive<Channel[]>;
+};
+export declare function useChannel($config: ChannelConfig | Ref<ChannelConfig>): {
+    execute: (data: any) => void;
+    config: Ref<ChannelConfig, ChannelConfig>;
+    loading: import("vue").ComputedRef<boolean | undefined>;
+    payload: import("vue").ComputedRef<any>;
+};

package/dist/types/lib/core/channel/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * hooks
+ */
+export { useChannelContainer, useChannel } from "./hooks";
+/**
+ * types
+ */
+export type { ChannelConfig, ChannelScope, ChannelResolver, ChannelConnection } from "./types";

package/dist/types/lib/core/channel/types.d.ts

@@ -0,0 +1,52 @@
+import type { Reactive, Ref } from "vue";
+import type { SocketStatus } from "../network";
+export type ChannelConfig = ChannelKey & ChannelResolver;
+export type ChannelScope = {
+    auth?: boolean;
+    broadcast?: boolean;
+};
+export type ChannelKey = {
+    handler: string;
+    url?: string;
+} & ChannelScope;
+export type ResolverKey = 'start' | 'error' | 'proceed' | 'stop' | 'done';
+export type ChannelResolver = {
+    token?: string;
+    start?: () => void;
+    error?: () => void;
+    proceed?: (payload: any) => void;
+    stop?: () => void;
+    done?: (response: any) => void;
+};
+export type ChannelKeyImpl = {
+    handler: string;
+    url: string;
+    auth: boolean;
+    broadcast: boolean;
+};
+export type ChannelStatus = {
+    loading: boolean;
+    payload: any;
+};
+export type Channel = {
+    key: ChannelKeyImpl;
+    status: Reactive<ChannelStatus>;
+    resolvers: {
+        [token: string]: ChannelResolver;
+    };
+};
+export type ChannelResponse = {
+    token: string;
+    resolver: ResolverKey;
+    payload: any;
+    timestamp: number;
+} & ChannelKey;
+export type ChannelHub = {
+    container: Reactive<Channel[]>;
+    mount: (config: ChannelConfig) => Channel;
+    unmount: (config: ChannelConfig) => void;
+};
+export type ChannelConnection = {
+    open: Function;
+    status: Ref<SocketStatus>;
+};

package/dist/types/lib/core/channel/utils/container.d.ts

@@ -0,0 +1,7 @@
+import type { Channel, ChannelConfig, ChannelKey } from "../types";
+export declare function useChannelContainer(): {
+    container: import("vue").Reactive<Channel[]>;
+    mount: (config: ChannelConfig) => Channel;
+    unmount: (config: ChannelConfig) => void;
+    getChannel: (key: ChannelKey) => Channel | undefined;
+};

package/dist/types/lib/core/channel/utils/hub.d.ts

@@ -0,0 +1,7 @@
+import type { ChannelResponse } from "../types.ts";
+export declare function useChannelHub(): {
+    container: import("vue").Reactive<import("../types.ts").Channel[]>;
+    invoke: (response: ChannelResponse) => void;
+    mount: (config: import("../types.ts").ChannelConfig) => import("../types.ts").Channel;
+    unmount: (config: import("../types.ts").ChannelConfig) => void;
+};

package/dist/types/lib/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channel';
+export * from './network';

package/dist/types/lib/core/network/hooks.d.ts

@@ -0,0 +1,4 @@
+export declare function useConnection(): {
+    open: Function;
+    status: import("vue").Ref<import("./types").SocketStatus, import("./types").SocketStatus>;
+};

package/dist/types/lib/core/network/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * hooks
+ */
+export { useHttp } from "./utils/http";
+export { useConnection, } from "./hooks";
+/**
+ * types
+ */
+export type { MessageFn, MessageType, SocketStatus } from './types';

package/dist/types/lib/core/network/types.d.ts

@@ -0,0 +1,3 @@
+export type SocketStatus = 'DISCONNECTED' | 'CONNECTING' | 'CONNECTED';
+export type MessageType = "success" | "info" | "warning" | "error";
+export type MessageFn = (message: string, type: MessageType) => void;

package/dist/types/lib/core/network/utils/http.d.ts

@@ -0,0 +1,5 @@
+import { type AxiosInstance } from 'axios';
+export declare function useHttp(): {
+    getAxiosInstance: (auth?: boolean) => AxiosInstance;
+    loading: import("vue").Ref<boolean, boolean>;
+};

package/dist/types/lib/core/network/utils/socket.d.ts

@@ -0,0 +1,6 @@
+import type { SocketStatus } from "../types";
+export declare function useSocket(baseURL: string): {
+    data: import("vue").Ref<any, any>;
+    open: import("@vueuse/shared").Fn;
+    status: import("vue").Ref<SocketStatus, SocketStatus>;
+};

package/dist/types/lib/data/dao/cogs/Model.d.ts

@@ -0,0 +1,9 @@
+import type { IModel, SearchType } from "../types";
+import type { DataItem } from "../../types";
+export default class Model {
+    results: DataItem[];
+    type: SearchType;
+    total: number;
+    root: number;
+    constructor(model?: IModel);
+}

package/dist/types/lib/data/dao/cogs/Search.d.ts

@@ -0,0 +1,12 @@
+import type { ISearch, Orders, SearchType } from "../types";
+import type { DataItemId } from "../../types";
+import Condition from "../../query/cogs/Condition";
+export default class Search {
+    type: SearchType;
+    orders: Orders;
+    page: number;
+    size: number;
+    root: DataItemId;
+    conditions: Condition[];
+    constructor(search?: ISearch, conditions?: Condition[]);
+}

package/dist/types/lib/data/dao/hooks.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from "vue";
+import type { IDao, Manager } from "./types";
+export declare function useDao($config: IDao | Ref<IDao>, batch?: boolean): {
+    config: Ref<IDao, IDao>;
+    manager: Manager;
+    loading: Ref<boolean, boolean> | import("vue").ComputedRef<boolean | undefined>;
+    payload: import("vue").ComputedRef<any> | import("vue").ComputedRef<{}>;
+};

package/dist/types/lib/data/dao/index.d.ts

@@ -0,0 +1,14 @@
+import Search from './cogs/Search';
+import Model from "./cogs/Model";
+/**
+ * cogs
+ */
+export { Search, Model };
+/**
+ * hooks
+ */
+export { useDao } from "./hooks";
+/**
+ * types
+ */
+export type { Manager, IDao, Orders, ISearch, IModel, SearchType } from "./types";

package/dist/types/lib/data/dao/types.d.ts

@@ -0,0 +1,39 @@
+import type { IMeta } from "../meta";
+import type { DataItem, DataItemId } from "../types";
+import Condition from "../query/cogs/Condition";
+import MetaView from "../meta/cogs/MetaView";
+import type { ChannelResolver, ChannelScope } from "../../core";
+import type Model from "./cogs/Model";
+export type Manager = {
+    save_many: (array: DataItem[]) => void;
+    delete_many: (conditions: Condition[]) => void;
+    insert_one: (item: DataItem) => Promise<DataItem>;
+    save_one: (item: DataItem) => Promise<DataItem>;
+    delete_one: (id: DataItemId) => Promise<boolean>;
+    find_one: (id: DataItemId) => Promise<DataItem>;
+    update: (template: DataItem, ...conditions: Condition[]) => Promise<boolean>;
+    find: (...conditions: Condition[]) => Promise<DataItem[]>;
+    search: (search: ISearch, conditions: Condition[]) => Promise<Model>;
+    values: (props: string[], ...conditions: Condition[]) => Promise<DataItem[]>;
+    meta_view: (code?: string) => Promise<MetaView>;
+};
+export type IDao = {
+    convertor?: (item: any) => void;
+} & IMeta & ChannelScope & ChannelResolver;
+export type Orders = {
+    [key: string]: 1 | -1;
+};
+export type SearchType = 'table' | 'tree';
+export type ISearch = {
+    type?: SearchType;
+    orders?: Orders;
+    page?: number;
+    size?: number;
+    root?: DataItemId;
+};
+export type IModel = {
+    results?: DataItem[];
+    type?: SearchType;
+    total?: number;
+    root?: number;
+};

package/dist/types/lib/data/hooks.d.ts

@@ -0,0 +1,245 @@
+import { type Ref } from "vue";
+import { type Meta, MetaView } from "./meta";
+import { type IDao, Model, Search } from "./dao";
+import type { DataItemId, IData } from "./types";
+import { Condition, type ICondition } from "./query";
+export declare function useData(config: Ref<IData>, search: Ref<Search>, complete: (keys: DataItemId[]) => void): {
+    model: Ref<{
+        results: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        }[];
+        type: import("./dao").SearchType;
+        total: number;
+        root: number;
+    }, Model | {
+        results: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        }[];
+        type: import("./dao").SearchType;
+        total: number;
+        root: number;
+    }>;
+    manager: import("./dao").Manager;
+    ticker: import("vue").ComputedRef<any> | import("vue").ComputedRef<{}>;
+    loading: Ref<boolean, boolean> | import("vue").ComputedRef<boolean | undefined>;
+    dao: Ref<{
+        convertor?: ((item: any) => void) | undefined;
+        db?: import("./types").Database | undefined;
+        entity: string | import("./meta").ValarMeta;
+        code?: string | undefined;
+        auth?: boolean | undefined;
+        broadcast?: boolean | undefined;
+        token?: string | undefined;
+        start?: (() => void) | undefined;
+        error?: (() => void) | undefined;
+        proceed?: ((payload: any) => void) | undefined;
+        stop?: (() => void) | undefined;
+        done?: ((response: any) => void) | undefined;
+    }, IDao | {
+        convertor?: ((item: any) => void) | undefined;
+        db?: import("./types").Database | undefined;
+        entity: string | import("./meta").ValarMeta;
+        code?: string | undefined;
+        auth?: boolean | undefined;
+        broadcast?: boolean | undefined;
+        token?: string | undefined;
+        start?: (() => void) | undefined;
+        error?: (() => void) | undefined;
+        proceed?: ((payload: any) => void) | undefined;
+        stop?: (() => void) | undefined;
+        done?: ((response: any) => void) | undefined;
+    }>;
+    core: import("vue").ComputedRef<import("./types").DataItem>;
+    finder: Ref<{
+        includes: {
+            [prop: string]: import("./query").Lookup;
+        };
+        excludes: {
+            [prop: string]: import("./query").Lookup;
+        };
+    }, import("./query").IFinder | {
+        includes: {
+            [prop: string]: import("./query").Lookup;
+        };
+        excludes: {
+            [prop: string]: import("./query").Lookup;
+        };
+    }>;
+    condition: Ref<{
+        includes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+        modes?: import("./meta").MetaModes | undefined;
+    }, ICondition | {
+        includes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: DataItemId | undefined;
+            sort?: DataItemId | undefined;
+            saved?: boolean | undefined;
+            name?: string | undefined;
+            disabled?: boolean | undefined;
+        } | undefined;
+        modes?: import("./meta").MetaModes | undefined;
+    }>;
+    conditions: import("vue").ComputedRef<Condition[]>;
+    view: Ref<{
+        $$validator?: import("./meta").MetaValidator | undefined;
+        $db?: import("./types").Database | undefined;
+        $entity?: string | undefined;
+        $code?: string | undefined;
+        $modes: import("./meta").MetaModes;
+        $isTree?: boolean | undefined;
+        $meta_name?: string | undefined;
+        $fields: {
+            [key: string]: import("./meta").MetaField;
+        };
+        $source?: {
+            $db?: import("./types").Database | undefined;
+            $entity?: string | undefined;
+            $code?: string | undefined;
+            $isTree?: boolean | undefined;
+            $fields?: {
+                [key: string]: import("./meta").IMetaField;
+            } | undefined;
+            $meta_name?: string | undefined;
+            $modes?: import("./meta").MetaModes | undefined;
+            $$validator?: import("./meta").MetaValidator | undefined;
+            id?: DataItemId | undefined;
+            name?: string | undefined;
+            lock?: boolean | undefined;
+            form_width?: number | undefined;
+            form_height?: number | undefined;
+            table_width?: number | undefined;
+            table_height?: number | undefined;
+            enable?: boolean | undefined;
+            show_header?: boolean | undefined;
+            allow_search?: boolean | undefined;
+            allow_order?: boolean | undefined;
+            allow_insert?: boolean | undefined;
+            allow_edit?: boolean | undefined;
+            allow_edit_on_form?: boolean | undefined;
+            allow_edit_on_cell?: boolean | undefined;
+            allow_edit_on_sort?: boolean | undefined;
+            allow_remove?: boolean | undefined;
+            allow_download?: boolean | undefined;
+            allow_upload?: boolean | undefined;
+        } | undefined;
+        lock?: boolean | undefined;
+        id?: DataItemId | undefined;
+        name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable: boolean;
+        show_header: boolean;
+        allow_search: boolean;
+        allow_order: boolean;
+        allow_insert: boolean;
+        allow_edit: boolean;
+        allow_edit_on_form: boolean;
+        allow_edit_on_cell: boolean;
+        allow_edit_on_sort: boolean;
+        allow_remove: boolean;
+        allow_download: boolean;
+        allow_upload: boolean;
+    }, MetaView | {
+        $$validator?: import("./meta").MetaValidator | undefined;
+        $db?: import("./types").Database | undefined;
+        $entity?: string | undefined;
+        $code?: string | undefined;
+        $modes: import("./meta").MetaModes;
+        $isTree?: boolean | undefined;
+        $meta_name?: string | undefined;
+        $fields: {
+            [key: string]: import("./meta").MetaField;
+        };
+        $source?: {
+            $db?: import("./types").Database | undefined;
+            $entity?: string | undefined;
+            $code?: string | undefined;
+            $isTree?: boolean | undefined;
+            $fields?: {
+                [key: string]: import("./meta").IMetaField;
+            } | undefined;
+            $meta_name?: string | undefined;
+            $modes?: import("./meta").MetaModes | undefined;
+            $$validator?: import("./meta").MetaValidator | undefined;
+            id?: DataItemId | undefined;
+            name?: string | undefined;
+            lock?: boolean | undefined;
+            form_width?: number | undefined;
+            form_height?: number | undefined;
+            table_width?: number | undefined;
+            table_height?: number | undefined;
+            enable?: boolean | undefined;
+            show_header?: boolean | undefined;
+            allow_search?: boolean | undefined;
+            allow_order?: boolean | undefined;
+            allow_insert?: boolean | undefined;
+            allow_edit?: boolean | undefined;
+            allow_edit_on_form?: boolean | undefined;
+            allow_edit_on_cell?: boolean | undefined;
+            allow_edit_on_sort?: boolean | undefined;
+            allow_remove?: boolean | undefined;
+            allow_download?: boolean | undefined;
+            allow_upload?: boolean | undefined;
+        } | undefined;
+        lock?: boolean | undefined;
+        id?: DataItemId | undefined;
+        name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable: boolean;
+        show_header: boolean;
+        allow_search: boolean;
+        allow_order: boolean;
+        allow_insert: boolean;
+        allow_edit: boolean;
+        allow_edit_on_form: boolean;
+        allow_edit_on_cell: boolean;
+        allow_edit_on_sort: boolean;
+        allow_remove: boolean;
+        allow_download: boolean;
+        allow_upload: boolean;
+    }>;
+    error: Ref<any, any>;
+    init: () => void;
+    reload: (keys?: DataItemId[]) => void;
+    delete_many: (keys: DataItemId[]) => void;
+    save_many: (array: any[]) => void;
+    switching: (meta: Meta) => void;
+};

package/dist/types/lib/data/index.d.ts

@@ -0,0 +1,6 @@
+export * from './dao';
+export * from './meta';
+export * from './model';
+export * from './query';
+export * from './types';
+export * from './hooks';

package/dist/types/lib/data/meta/cogs/MetaField.d.ts

@@ -0,0 +1,47 @@
+import MetaRefer from "./MetaRefer";
+import MetaFormat from "./MetaFormat";
+import type { IMetaField, MetaFieldDomain, MetaFieldTool } from "../types";
+import type { Database } from "../../types";
+export default class MetaField {
+    $db?: Database;
+    $entity?: string;
+    $code?: string;
+    id?: string | number;
+    prop: string;
+    label?: string;
+    name: string;
+    domain: MetaFieldDomain;
+    tool: MetaFieldTool;
+    refer: MetaRefer;
+    format: MetaFormat;
+    disabled: boolean;
+    not_null: boolean;
+    allow_edit: boolean;
+    allow_order: boolean;
+    allow_search: boolean;
+    allow_download: boolean;
+    allow_upload: boolean;
+    allow_update: boolean;
+    unit: string;
+    column_width: number;
+    align: 'left' | 'center' | 'right';
+    fixed: '' | 'left' | 'right';
+    header_color: string;
+    cell_color: string;
+    edit_on_table: boolean;
+    hide_on_table: boolean;
+    span: number;
+    hide_on_form: boolean;
+    hide_on_form_edit: boolean;
+    hide_on_form_insert: boolean;
+    hide_on_form_branch: boolean;
+    hide_on_form_leaf: boolean;
+    constructor(field?: IMetaField);
+    static DOMAINS: {
+        multiple: string[];
+        linkage: string[];
+        referred: string[];
+        orderable: string[];
+        editable: string[];
+    };
+}

package/dist/types/lib/data/meta/cogs/MetaFormat.d.ts

@@ -0,0 +1,26 @@
+import type { IMetaFormat, MetaFormatFrequency, MetaFormatType } from "../types";
+import type { DataItemId } from "../../types";
+export default class MetaFormat {
+    $maxlength: number;
+    maxlength: number;
+    type: MetaFormatType;
+    min: number | null;
+    max: number | null;
+    step: number | null;
+    precision: number | null;
+    step_strictly: boolean;
+    frequency: MetaFormatFrequency;
+    maximum: number;
+    accept: string[];
+    width: number | null;
+    height: number | null;
+    file_name_field: string | null;
+    locked: boolean;
+    set: {
+        [label: DataItemId]: string;
+    };
+    multiple: boolean;
+    constructor(format?: IMetaFormat);
+    static FILE_TYPES: string[];
+    static DATE_TYPES: any;
+}