jamis/lib/sdk/loader.d.ts

一种支持通过JSON配置方式生成页面的组件库

import react from 'react';
import ReactDOM from 'react-dom';
import reactDropzone from 'react-dropzone';
import moment from 'moment';
import * as mobx from 'mobx';
import * as mobxStateTree from 'mobx-state-tree';
import * as reactTransitionGroup from 'react-transition-group';
import sortablejs from 'sortablejs';
import qs from 'qs';
import * as pathToRegexp from 'path-to-regexp';
import * as history from 'history';
import * as amis from '../index';
import { embed as amisEmbed } from './embed';
export declare const mapping: {
    readonly react: typeof react;
    readonly 'react-dom': typeof ReactDOM;
    readonly 'immutability-helper': <T, C extends import("immutability-helper").CustomCommands<object> = never>(object: T, $spec: import("immutability-helper").Spec<T, C>) => T;
    readonly 'react-cropper': () => Promise<typeof import("react-cropper")>;
    readonly 'react-dropzone': typeof reactDropzone;
    readonly classnames: amis.ClassNamesFn;
    readonly cx: amis.ClassNamesFn;
    readonly axios: import("axios").AxiosStatic;
    readonly exceljs: () => Promise<{
        default: typeof import("exceljs");
        RelationshipType: typeof import("exceljs").RelationshipType;
        DocumentType: typeof import("exceljs").DocumentType;
        PaperSize: typeof import("exceljs").PaperSize;
        ReadingOrder: typeof import("exceljs").ReadingOrder;
        ErrorValue: typeof import("exceljs").ErrorValue;
        ValueType: typeof import("exceljs").ValueType;
        FormulaType: typeof import("exceljs").FormulaType;
        Anchor: typeof import("exceljs").Anchor;
        Workbook: typeof import("exceljs").Workbook;
        config: typeof import("exceljs").config;
        stream: typeof import("exceljs").stream;
    }>;
    readonly moment: typeof moment;
    readonly mobx: typeof mobx;
    readonly mobxStateTree: typeof mobxStateTree;
    readonly 'react-transition-group': typeof reactTransitionGroup;
    readonly papaparse: () => Promise<{
        default: typeof import("papaparse");
        parse<T, TFile extends import("papaparse").LocalFile = import("papaparse").LocalFile>(file: TFile, config: import("papaparse").ParseLocalConfig<T, TFile>): void;
        parse<T>(url: string, config: import("papaparse").ParseRemoteConfig<T>): void;
        parse<T>(csvString: string, config: import("papaparse").ParseWorkerConfig<T> & {
            download?: false | undefined;
        }): void;
        parse<T>(csvString: string, config?: import("papaparse").ParseConfig<T> & {
            download?: false | undefined;
            worker?: false | undefined;
        }): import("papaparse").ParseResult<T>;
        parse<T>(source: import("papaparse").LocalFile | string, config: import("papaparse").ParseLocalConfig<T, import("papaparse").LocalFile> & ((import("papaparse").ParseConfig<T> & {
            download?: false | undefined;
            worker?: false | undefined;
        }) | (import("papaparse").ParseWorkerConfig<T> & {
            download?: false | undefined;
        }) | import("papaparse").ParseRemoteConfig<T>)): void;
        parse(stream: typeof import("papaparse").NODE_STREAM_INPUT, config?: import("papaparse").ParseConfig): import("stream").Duplex;
        unparse<T>(data: T[] | import("papaparse").UnparseObject<T>, config?: import("papaparse").UnparseConfig): string;
        BAD_DELIMITERS: readonly string[];
        RECORD_SEP: "\u001E";
        UNIT_SEP: "\u001F";
        WORKERS_SUPPORTED: boolean;
        NODE_STREAM_INPUT: typeof import("papaparse").NODE_STREAM_INPUT;
        LocalChunkSize: number;
        RemoteChunkSize: number;
        DefaultDelimiter: string;
        Parser: typeof import("papaparse").Parser;
    }>;
    readonly echarts: () => Promise<any>;
    readonly sortablejs: typeof sortablejs;
    readonly amis: typeof amis;
    readonly amisEmbed: typeof amisEmbed;
    readonly 'amis/embed': {
        readonly embed: typeof amisEmbed;
    };
    readonly qs: typeof qs;
    readonly 'path-to-regexp': typeof pathToRegexp;
    readonly history: typeof history;
};
export declare const amisRequire: (key: keyof typeof mapping) => any;
export type amisRequire = typeof amisRequire;