import * as cesium from 'cesium';
import { HeadingPitchRange, Viewer, ImageryLayer, EllipsoidTerrainProvider, CesiumTerrainProvider, SceneMode } from 'cesium';

declare const Config: {
    prefixCls: string;
    prefix(suffix: string): string;
};

declare const _default: {
    "en-US": {
        "dde-earth": {
            dde: string;
        };
    };
    "zh-CN": {
        "dde-earth": {
            dde: string;
        };
    };
};

type Tail<T extends any[]> = ((...args: T) => void) extends (head: any, ...tail: infer R) => void ? R : never;
type EventArgs = {
    [key: string]: any;
};
type EventNames<M extends EventArgs> = Extract<keyof M, string>;
type NestedKeyOf<ObjectType> = ObjectType extends object ? {
    [Key in keyof ObjectType]: `${Key & string}` | `${Key & string}.${NestedKeyOf<ObjectType[Key]>}`;
}[keyof ObjectType] : never;
type NestedValueOf<ObjectType, Property extends string> = Property extends `${infer Key}.${infer Rest}` ? Key extends keyof ObjectType ? NestedValueOf<ObjectType[Key], Rest> : never : Property extends keyof ObjectType ? ObjectType[Property] : never;
type NamespaceKeys<ObjectType, Keys extends string> = {
    [Property in Keys]: NestedValueOf<ObjectType, Property> extends string ? never : Property;
}[Keys];
type MessageKeys<ObjectType, Keys extends string> = {
    [Property in Keys]: NestedValueOf<ObjectType, Property> extends string ? Property : never;
}[Keys];
type NestedKeys<Intl> = NamespaceKeys<Intl, NestedKeyOf<Intl>> | undefined;
type NestedIds<Intl, NestedKey extends NestedKeys<Intl> = never> = MessageKeys<NestedValueOf<{
    "!": Intl;
}, [
    NestedKey
] extends [never] ? "!" : `!.${NestedKey}`>, NestedKeyOf<NestedValueOf<{
    "!": Intl;
}, [
    NestedKey
] extends [never] ? "!" : `!.${NestedKey}`>>>;
type CheckUndefined<T> = T extends undefined ? never : T;
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

declare function findMostSimilarString(strings: string[], target: string): string | null;
/**
 * Deeply merges multiple objects into the original object.
 * @param target The original object where other objects will be merged into.
 * @param sources The list of objects to merge.
 * @returns The merged original object.
 */
declare function deepMerge(target: any, ...sources: any[]): any;
declare function generateUUID(): string;
declare function convertToAsync<T = any>(result: T | Promise<T>): Promise<T>;
declare function convertToAsyncFunc<T extends (...args: any[]) => any>(func: T): (...args: Parameters<T>) => Promise<ReturnType<T>>;
declare function mergeAndDistinctArrays<T>(...arrays: T[][]): T[];

declare class I18N {
    private _locale;
    private _localeMessages;
    private _messages;
    options: I18N.Options;
    get locales(): string[];
    get locale(): I18N.Languages;
    set locale(val: I18N.Languages);
    constructor(options?: Partial<I18N.Options>);
    getT<Intl = I18N.IntlMessages, NestedKey extends NestedKeys<Intl> = never>(namespace?: NestedKey): (id: NestedIds<Intl, NestedKey>, values?: Record<string, any>) => string | undefined;
    private _replaceValues;
    private _translateFunc;
    extend(messages: any): void;
}
declare namespace I18N {
    type IntlMessages = (typeof _default)["en-US"];
    interface LocaleMessages extends Record<keyof typeof _default, any> {
    }
    type Languages = keyof LocaleMessages;
    type ExtendMessages<Intl = any> = {
        [key in Languages]?: DeepPartial<Intl>;
    };
    const defaultOptions: Options;
    interface Options {
        defaultLanguage: Languages;
        fallBackLanguage?: Languages | undefined | null;
        onLocaleChanged?(locale: string): void;
    }
    type TranslateFunc<I = {}, Intl = I & IntlMessages> = <NestedKey extends NestedKeys<Intl> = never>(namespace?: NestedKey | undefined) => (id: NestedIds<Intl, NestedKey>, values?: Record<string, any>) => string | undefined;
}

declare class EventEmitter {
    callbacks: {
        [key: string]: Function[];
    };
    on<T extends Earth.EventTypes = Earth.EventTypes>(event: T, fn: Earth.EventFunc<T>): this;
    emit<T extends Earth.EventTypes>(event: T, ...args: Earth.Events[T]): this;
    off<T extends Earth.EventTypes>(event: T, fn?: Earth.EventFunc<T>): this;
    destroy(): void;
}

declare abstract class LayerItem<Lyr extends LayerManager.BaseLayer = LayerManager.BaseLayer, Instance = any> {
    readonly earth: Earth;
    readonly options: LayerItem.Options;
    readonly data: Lyr;
    readonly method: Lyr["method"];
    protected _instance?: Instance;
    readonly id: any;
    protected _ready: boolean;
    protected _isDestroyed: boolean;
    protected abstract readonly defaultRenderOptions: Lyr["renderOptions"];
    protected _renderOptions?: Lyr["renderOptions"];
    get renderOptions(): Lyr["renderOptions"] | undefined;
    get isDestroyed(): boolean;
    get ready(): boolean;
    abstract get show(): boolean;
    abstract set show(value: boolean);
    get instance(): Instance | undefined;
    constructor(earth: Earth, data: Lyr, options?: LayerItem.Options);
    initial(): Promise<this>;
    protected abstract _init(data: Lyr): Promise<Instance>;
    abstract zoomTo(options?: LayerItem.ZoomToOptions): void;
    protected abstract _remove(): boolean | Promise<boolean>;
    remove(): Promise<boolean>;
    protected abstract _render(renderOptions: Lyr["renderOptions"]): Promise<Instance | undefined>;
    render(renderOptions: Lyr["renderOptions"]): Promise<Instance | undefined>;
    destroy(): void;
}
declare namespace LayerItem {
    interface Options<Lyr extends LayerManager.BaseLayer = LayerManager.BaseLayer> {
        defaultRenderOptions?: Lyr["renderOptions"];
    }
    type ZoomToOptions = {
        duration?: number;
        maximumHeight?: number;
        offset?: HeadingPitchRange;
    };
}

declare class LayerManager {
    readonly earth: Earth;
    private _isDestroyed;
    private _baseLayer?;
    private _layerList;
    private _loaders;
    readonly viewer: Viewer;
    get isDestroyed(): boolean;
    get baseLayer(): ImageryLayer | undefined;
    get layerList(): LayerItem<LayerManager.BaseLayer<string, any>, any>[];
    get loaders(): Record<string, LayerManager.Loader<LayerManager.BaseLayer<string, any>, any>>;
    set baseLayer(layer: ImageryLayer | undefined);
    constructor(earth: Earth, options?: LayerManager.Options);
    addLoader(loaders: Record<string, LayerManager.Loader>): void;
    removeLoader(method: string | string[]): void;
    getLoaderByMethod(method: string): LayerManager.Loader<LayerManager.BaseLayer<string, any>, any>;
    changeBaseLayer<Method extends LayerManager.LoaderMethods>(data: LayerManager.LoaderTypes[Method]["data"] | null | undefined): Promise<void>;
    addLayer<Method extends LayerManager.LoaderMethods>(data: LayerManager.LoaderTypes[Method]["data"], options?: LayerManager.AddLayerOptions): Promise<Awaited<LayerManager.LoaderTypes[Method]["layerItem"]> | undefined>;
    /**
     * remove layer from the layer list
     * @param param layerName or LayerItem object
     * @returns removed successfully or not
     */
    removeLayer(param: string | LayerItem): Promise<boolean>;
    getLayerById(id: string): LayerItem<LayerManager.BaseLayer<string, any>, any> | undefined;
    destroy(): void;
}
declare namespace LayerManager {
    export interface Options {
        baseLayer?: false | ImageryLayer;
    }
    export interface AddLayerOptions {
        zoom?: boolean;
    }
    export interface BaseLayer<Method = string, Render extends Record<string, any> = any> {
        id?: string;
        layerName?: string;
        method: Method;
        renderOptions?: Render;
    }
    export type Loader<T extends BaseLayer = BaseLayer, Instance = any> = (earth: Earth, data: T) => LayerItem<T, Instance> | Promise<LayerItem<T, Instance>>;
    export interface Loaders {
    }
    type ExtractLoaderTypes<T extends Loaders> = {
        [K in keyof T]: {
            data: T[K] extends Loader<infer U, any> ? U : never;
            instance: T[K] extends Loader<any, infer V> ? V : any;
            layerItem: T[K] extends Loader<any, any> ? ReturnType<T[K]> : any;
        };
    };
    export type LoaderTypes = ExtractLoaderTypes<Loaders>;
    export type LoaderMethods = keyof LoaderTypes;
    export {  };
}

declare abstract class BasePlugin<InitOptions extends any[] = [], Intl extends Record<string, any> = any> {
    readonly options?: BasePlugin.Options<Intl> | undefined;
    /** plugin name, do not repeat, will appear in warnings or errors */
    readonly name: string;
    /** Internationalized Dictionary */
    protected _intl: I18N.ExtendMessages<Intl>;
    protected _earth: Earth;
    protected _enable: boolean;
    protected _isDestroyed: boolean;
    get earth(): Earth;
    get viewer(): cesium.Viewer;
    /** get or set plugin's enable */
    get enable(): boolean;
    set enable(val: boolean);
    get isDestroyed(): boolean;
    constructor(options?: BasePlugin.Options<Intl> | undefined);
    /** should be executed when implement init function */
    protected _init(_earth: Earth): void;
    abstract init(_earth: Earth, ..._options: InitOptions): this;
    /** get translation's api */
    protected _getT: I18N.TranslateFunc<Intl>;
    destroy(): void;
}
declare namespace BasePlugin {
    interface Options<Intl = any> {
        name?: string;
        intl?: I18N.ExtendMessages<Intl>;
    }
}

declare abstract class WithEventPlugin<InitOptions extends any[] = any[], Intl extends Record<string, any> = any, Events extends string = string, Args extends any[] = []> extends BasePlugin<InitOptions, Intl> {
    readonly eventList: Events[];
    constructor(options?: WithEventPlugin.Options<Intl>);
    abstract on(event: Events, fn: (...args: Args) => void): any;
    abstract off(event: Events, fn?: (...args: Args) => void): any;
}
declare namespace WithEventPlugin {
    interface Options<Intl = any> extends BasePlugin.Options<Intl> {
    }
}

type IPlugin = WithEventPlugin | BasePlugin;

declare class PluginManager {
    readonly earth: Earth;
    readonly plugins: Record<string, IPlugin>;
    private _isDestroyed;
    constructor(earth: Earth, plugins?: Record<string, IPlugin>);
    get isDestroyed(): boolean;
    use<T extends IPlugin>(plugin: T, ...options: Tail<Parameters<T["init"]>>): T;
    get<T extends IPlugin = IPlugin>(param: string | Function): T | undefined;
    getPluginWithEvent<T extends Earth.EventTypes = Earth.EventTypes>(event: T): WithEventPlugin<any[], any, T, Earth.Events[T]> | undefined;
    remove(name: string | string[]): void;
    destroy(): void;
}

declare class TerrainManager {
    readonly earth: Earth;
    private _data;
    private _loaders;
    get terrain(): cesium.TerrainProvider;
    get loaders(): Record<string, TerrainManager.Loader<any, any>>;
    get data(): any;
    constructor(earth: Earth, options?: TerrainManager.Options);
    addLoader(loaders: Record<string, TerrainManager.Loader>): void;
    removeLoader(method: string | string[]): void;
    getLoaderByMethod(method: string): TerrainManager.Loader<any, any>;
    setTerrain<Method extends TerrainManager.LoaderMethods>(data?: TerrainManager.LoaderTypes[Method]["data"]): Promise<Awaited<TerrainManager.LoaderTypes[Method]["instance"]> | EllipsoidTerrainProvider | undefined>;
}
declare namespace TerrainManager {
    export interface Options<T extends LoaderMethods = LoaderMethods> {
        terrain?: [T] extends [never] ? undefined : LoaderTypes[T]["data"];
    }
    export type DataWithMethod<T extends string, U extends Record<string, any>> = {
        type: T;
    } & U;
    export type Loader<T = any, Instance = any> = (data: T) => Instance | Promise<Instance>;
    type ExtractLoaderTypes<T extends Loaders> = {
        [K in keyof T]: {
            data: T[K] extends Loader<infer U, any> ? U : never;
            instance: T[K] extends Loader<any, infer V> ? V : any;
        };
    };
    export interface Loaders {
    }
    interface CesiumWorldTerrainLoader {
        cesium: (data: DataWithMethod<"cesium", CesiumTerrainProvider.ConstructorOptions>) => CesiumTerrainProvider;
    }
    export interface Loaders extends CesiumWorldTerrainLoader {
    }
    export type LoaderTypes = ExtractLoaderTypes<Loaders>;
    export type LoaderMethods = keyof LoaderTypes;
    export type LoaderDatas = ExtractLoaderTypes<Loaders>[LoaderMethods]["data"];
    export {  };
}

declare class Earth {
    readonly container: string | Element | Viewer;
    private _isDestroyed;
    private _ready;
    readonly viewer: Viewer;
    readonly options: Earth.EarthOptions;
    readonly pluginManager: PluginManager;
    readonly i18n: I18N;
    readonly layerManager: LayerManager;
    readonly eventEmitter: EventEmitter;
    readonly terrainManager: TerrainManager;
    constructor(container: string | Element | Viewer, options?: Earth.EarthOptions);
    get ready(): boolean;
    get isDestroyed(): boolean;
    /**
     * Get or set the scene display mode
     * @default SceneMode.SCENE3D
     */
    get sceneMode(): SceneMode;
    set sceneMode(mode: SceneMode);
    resetStatus(): void;
    resetView(viewPort?: number[]): void;
    on<T extends Earth.EventTypes = Earth.EventTypes>(event: T, fn: Earth.EventFunc<T>): any;
    off<T extends Earth.EventTypes = Earth.EventTypes>(event: T, fn?: Earth.EventFunc<T>): any;
    emit: (typeof EventEmitter.prototype)["emit"];
    usePlugin: (typeof PluginManager.prototype)["use"];
    getPlugin: (typeof PluginManager.prototype)["get"];
    removePlugin: (typeof PluginManager.prototype)["remove"];
    /** add layer using layer loader */
    addLayer: (typeof LayerManager.prototype)["addLayer"];
    removeLayer: (typeof LayerManager.prototype)["removeLayer"];
    /** set terrain using terrain loader */
    setTerrain: (typeof TerrainManager.prototype)["setTerrain"];
    destroy(): void;
}
declare namespace Earth {
    type EarthOptions = {
        /** plugins list */
        plugins?: IPlugin[];
        /**
         * scene background color
         * @default'#00000099'
         */
        backgroundColor?: string;
        /**
         * globe base color
         * @default'#4F4F4F'
         */
        baseColor?: string;
        /**
         * default viewport
         * @default[116.3, 39.9, 20000000]
         */
        defaultViewPort?: number[];
        toolOptions?: {
            i18n?: Partial<I18N.Options>;
        };
    } & Viewer.ConstructorOptions;
    const defaultOptions: EarthOptions;
    interface Events {
        "layer:add": [layerItem: LayerItem];
        "layer:remove": [id: string];
        "layer:render": [layerItem: LayerItem];
        "lang:change": [lang: string];
        "terrain:change": [terrain: any];
    }
    type EventTypes = keyof Events;
    type EventFunc<T extends keyof Events = keyof Events> = (...args: Events[T]) => void;
    interface AddLayerOptions {
        zoom?: boolean;
    }
}

declare const Debug: {
    info: (message: string | [
        scope: string,
        msg: string
    ], ...optionalParams: any[]) => void;
    warn: (message: string | [
        scope: string,
        msg: string
    ], ...optionalParams: any[]) => void;
    error: (message: string | [
        scope: string,
        msg: string
    ], ...optionalParams: any[]) => void;
    trace: (message: string | [
        scope: string,
        msg: string
    ], ...optionalParams: any[]) => void;
};

export { BasePlugin, type CheckUndefined, Config, Debug, type DeepPartial, Earth, type EventArgs, EventEmitter, type EventNames, I18N, type IPlugin, LayerItem, LayerManager, type MessageKeys, type NamespaceKeys, type NestedIds, type NestedKeyOf, type NestedKeys, type NestedValueOf, PluginManager, type Tail, TerrainManager, WithEventPlugin, convertToAsync, convertToAsyncFunc, deepMerge, findMostSimilarString, generateUUID, mergeAndDistinctArrays };