plugin-tls 0.0.0 → 1.1.0

package/dist/plugin-tls.d.ts

@@ -0,0 +1,1329 @@
+/**
+ * 插件系统
+ *
+ * @remarks
+ * 主要负责 SDK 的插件机制的实现
+ * 插件系统应该具备以下功能：
+ * - 注册插件
+ * - 可扩展类的静态级功能
+ * - 可扩展类的实例级功能
+ * - 可自定义暴露的功能
+ * - 可拥有私有自身的API
+ *
+ * 额外的也提供了其它的功能
+ * - 全局选项
+ * - 实例选项
+ *
+ * @packageDocumentation
+ */
+
+import { AnyFunction } from 'type-tls';
+import type { Optional } from 'type-tls';
+
+/**
+ * 创建增加带有选项机制的装饰器
+ *
+ * @remarks
+ * 类装饰器的工厂函数
+ *
+ * @param options - 选项内容
+ * @returns
+ */
+export declare function addDefaultOptions<Options>(options: Options, name?: Optional<string>): <Clas extends new (...args: any) => any>(target: Clas) => void;
+
+/**
+ * 创建增加带有选项机制的装饰器
+ *
+ * @remarks
+ * 静态属性装饰器
+ *
+ * @param options - 选项内容
+ * @returns
+ */
+export declare function addInstOptions<Clas extends new (...args: any) => any>(target: Clas, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+
+/**
+ * 对一组函数批量调用 apply
+ * @param funArr
+ * @param thisArg
+ * @param args
+ */
+export declare function allFunctionApply<T, A extends any[], R>(funArr: ((this: T, ...args: A) => void)[], thisArg: T, args: A): void;
+
+/**
+ * 将 HOST 变成插件宿主类型
+ */
+export declare type BecomePluginHost<HOST extends new (...args: any) => any, Plugin extends IPlugin<HOST, any> = IPlugin<HOST, any>> = HOST & IPluginHostConstructor<HOST & IPluginHostConstructor<HOST, Plugin>, Plugin> & ReplaceConstructorReturn<HOST, InstanceType<HOST> & IPluginHost<HOST & IPluginHostConstructor<HOST & IPluginHostConstructor<HOST, Plugin>, Plugin>>>;
+
+/**
+ * 变成插件宿主
+ * @remarks
+ * 也可作为装饰器
+ *
+ * 子类需要在构建函数中调用 `this.pluginManager.created(this);`
+ *
+ * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+ * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+ * @param target
+ * @param context
+ * @returns
+ */
+export declare function becomePluginHost<HOST extends new (...args: any) => any, Plugin extends IPlugin<HOST, any> = IPlugin<HOST, any>>(target: HOST): BecomePluginHost<HOST, Plugin>;
+
+/**
+ * 插件缩主类的装饰器（继承版）
+ * @remarks
+ * 通过继承实现
+ */
+export declare function becomePluginHost_Extends<HOST extends new (...args: any) => any>(target: HOST): {
+    new (...args: any): {
+        [x: string]: any;
+        /**
+         * 插件管理器 {@link PluginHost.pluginManager}
+         */
+        readonly pluginManager: PluginManager<any & HOST, IPlugin<any & HOST, any>>;
+        /**
+         * 实例的注册插件的方法
+         * @param plugin
+         * @param options
+         * @returns
+         */
+        use<Plugin_1 extends IPlugin<any & HOST, any>>(plugin: Plugin_1, ...options: FormatUsePluginParameters<Plugin_1>): void | PluginCreatedReturnType<Plugin_1>;
+        /**
+         * 销毁实例
+         * @returns
+         */
+        destroy(): void;
+    };
+    /**
+     * 插件管理器
+     */
+    readonly pluginManager: PluginManager<any & HOST, IPlugin<any & HOST, any>>;
+    _pluginManager: PluginManager<any & HOST, IPlugin<any & HOST, any>>;
+    /**
+     * {@inheritDoc PluginManager.use}
+     */
+    use<Plugin_2 extends IPlugin<any & HOST, any>>(plugin: Plugin_2, ...options: FormatUsePluginParameters<Plugin_2>): void | ReturnType<Plugin_2["used"]>;
+} & HOST;
+
+/**
+ * 变成插件宿主
+ * @remarks
+ * 也可作为装饰器
+ * @param target
+ * @param context
+ * @returns
+ */
+export declare function becomePluginHost_Proxy<HOST extends new (...args: any) => any, Plugin extends IPlugin<HOST, any> = IPlugin<HOST, any>>(target: HOST): HOST;
+
+/**
+ * 使 HOST 变成 层级选项的宿主类型
+ */
+export declare type BecomeTierModeOptionsHost<HOST extends new (...args: any) => any, Options extends {} = any, Mode extends string | number = string> = HOST & ITierModeOptionsHostConstructor<Options, Mode> & ReplaceConstructorReturn<HOST, InstanceType<HOST> & ITierModeOptionsHost<Options, Mode>>;
+
+/**
+ * 使 host 变成 层级选项的宿主类型
+ * @param host
+ * @param context
+ * @returns
+ */
+export declare function becomeTierModeOptionsHost<HOST extends new (...args: any) => any, Mode extends string | number, Options extends {}>(host: HOST, mode: Mode, options?: Options): BecomeTierModeOptionsHost<HOST, Options, Mode>;
+
+/**
+ * 使 HOST 变成 层级选项的宿主类型
+ */
+export declare type BecomeTierOptionsHost<HOST extends new (...args: any) => any, Options extends {} = any> = HOST & ITierOptionsHostConstructor<Options> & ReplaceConstructorReturn<HOST, InstanceType<HOST> & ITierOptionsHost<Options>>;
+
+/**
+ * 使 host 变成 层级选项的宿主类型
+ * @param host
+ * @param context
+ * @returns
+ */
+export declare function becomeTierOptionsHost<HOST extends new (...args: any) => any, Options extends {} = any>(host: HOST, option?: Options): BecomeTierOptionsHost<HOST, any>;
+
+/**
+ * 类扩展者
+ */
+export declare type ClassExtender<C extends new (...args: any) => any> = C & ClassExtenderPrivateMember<C>;
+
+/**
+ * 类扩展者的私有方法
+ */
+export declare interface ClassExtenderPrivateMember<C extends new (...args: any) => any> {
+    /**
+     * 保存扩展类自定义的构建函数
+     */
+    readonly _constructors: ((this: InstanceType<C>, ...args: ConstructorParameters<C>) => void)[];
+    /**
+     * 保存扩展类自定义的销毁函数
+     */
+    readonly _destroys: ((this: InstanceType<C>) => void)[];
+}
+
+/**
+ * 类扩展者的私有方法
+ */
+export declare interface ClassExtenderPrivateMemberWithInit<C extends new (...args: any) => any, InitParams extends any[] = any> extends ClassExtenderPrivateMember<C> {
+    /**
+     * 保存扩展类中自定义的初始化方法
+     */
+    readonly _inits: ((this: InstanceType<C>, ...args: InitParams) => void)[];
+}
+
+/**
+ * 类扩展者
+ */
+export declare type ClassExtenderWithInit<C extends new (...args: any) => any, InitParams extends any[] = any> = C & ClassExtenderPrivateMemberWithInit<C, InitParams>;
+
+/**
+ * 类的类型、构造函数的类型
+ *
+ * @typeParam Arg - 构建函数的参数类型
+ * @typeParam Instance - 构建函数的返回的实例类型
+ */
+export declare interface ClassType<Arg extends any[] = any, Instance = any> {
+    new (...args: Arg): Instance;
+}
+
+/**
+ * 一般模式的名字
+ * @remarks
+ * 一般模式，其它模式可以继承该模式
+ */
+export declare const commonModeName = "common";
+
+/**
+ * 创建扩展的私有方法的调用者
+ * @param cla
+ * @returns constructed：执行所有 `_constructor` 的便利函数；initialized：执行所有 `_inits` 的便利函数
+ */
+export declare function createCallerOfPrivateMemberOfExtend<C extends ClassType>(cla: C): {
+    constructed: (thisArg: any, args: any[]) => void;
+    initialized: (thisArg: any, args: any[]) => void;
+    destroyed: (thisArg: any, args: any[]) => void;
+};
+
+/**
+ * 创建定义混合的类型便利函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link defineMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @returns 可以用于 定义混合的 类型便利函数
+ */
+export declare function createDefineMixin<T>(): <M>(target: T, mixin: M & ThisType<T & M>) => M & ThisType<T & M>;
+
+/**
+ * 创建用于扩展目标工具函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link extendTarget} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createExtendTarget<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
+/**
+ * 创建用于扩展目标工具函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link extendTargetWithInit} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createExtendTargetWithInit<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtendWithInit<C, any>) => ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
+/**
+ * 创建用于混合目标工具函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link mixinTarget} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @returns 可以用于 混合目标 的便利函数
+ */
+export declare function createMixinTarget<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M> & T;
+
+/**
+ * 创建插件的缩主类
+ *
+ * @remarks
+ * 比 直接使用 PluginHost 提供了完善的类型推导
+ *
+ * 子类需要在构建函数中调用 `this.pluginManager.created(this);`
+ *
+ * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+ * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+ * @returns
+ */
+export declare function createPluginHost<HOST, Plugin extends IPlugin<HOST, any> = IPlugin<HOST, any>>(): {
+    new (): {
+        /**
+         *  插件管理器 {@link CEarth.pluginManager}
+         */
+        readonly pluginManager: PluginManager<any, IPlugin<any, any>>;
+        /**
+         /**
+         * 实例的注册插件的方法
+         * @param plugin
+         * @param options
+         * @returns
+         */
+        use<P extends Plugin>(plugin: P, ...options: FormatUsePluginParameters<P>): void | PluginCreatedReturnType<P>;
+        /**
+         * 销毁实例
+         * @returns
+         */
+        destroy(): void;
+    };
+    /**
+     * PluginHost 的插件管理器
+     */
+    readonly pluginManager: PluginManager<typeof PluginHost & HOST, Plugin>;
+    _pluginManager: PluginManager<typeof PluginHost & HOST, Plugin>;
+    /**
+     * {@inheritDoc PluginManager.use}
+     */
+    use<P_1 extends Plugin>(plugin: P_1, ...options: FormatUsePluginParameters<P_1>): void | ReturnType<P_1["used"]>;
+};
+
+/**
+ * 创建属性设置器
+ *
+ * @param target
+ * @param props
+ * @returns 会返回一个 set  和 unset 方法，set 方法用户将 props 中描述的属性值设置到 target 中， unset 方法用于恢复成原来的值
+ */
+export declare function createPropertySetter(target: any, props: any): {
+    set: () => void;
+    unset: () => void;
+};
+
+/**
+ * 创建用于扩展目标的便捷函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link targetExtend} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createTargetExtend<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>) => E & ThisType<C & E>;
+
+/**
+ * 创建用于扩展目标的便捷函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link targetExtendWithInit} 的功能一样，唯一区别是不再需要接收 cla 参数了
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @returns 可以用于 扩展目标 的便利函数
+ */
+export declare function createTargetExtendWithInit<C extends ClassType>(cla: C): <E>(ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtendWithInit<C, any>) => E & ThisType<C & E>;
+
+/**
+ * 创建用于混合目标的便捷函数
+ *
+ * @remarks
+ * 它返回的便利函数的功能与 {@link targetMixin} 的功能一样，唯一区别是不再需要接收 target 参数了
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @returns 可以用于 混合目标 的便利函数
+ */
+export declare function createTargetMixin<T>(target: T): <M>(m: M & ThisType<T & M>) => M & ThisType<T & M>;
+
+/**
+ * 创建带有选项机制的插件宿主类
+ * @remakers
+ * 比 直接使用 ModeOptionsPluginHost 提供了完善的类型推导
+ *
+ * @returns
+ */
+export declare function createTierModeOptionsPluginHost<HOST, Options extends {}, Mode extends string | number = string>(): {
+    new (options: Options): {
+        /**
+         * 实例级的默认选项
+         */
+        readonly modeOptions: TierModeOptions<Mode, Options>;
+        _modeOptions: TierModeOptions<Mode, Options>;
+        mode: Mode;
+        readonly options: Options;
+        /**
+         * 使 host 变成 层级选项的宿主类型
+         * @param host
+         * @param context
+         * @returns
+         */
+        readonly pluginManager: PluginManager<any, IPlugin<any, any>>;
+        use<P extends IPlugin<HOST, any>>(plugin: P, ...options: FormatUsePluginParameters<P>): void | PluginCreatedReturnType<P>;
+        destroy(): void;
+    };
+    /**
+     * 全局级别的默认选项
+     */
+    readonly modeOptions: TierModeOptions<string, Options>;
+    readonly pluginManager: PluginManager<PluginHost & HOST, IPlugin<HOST, any>>;
+    _pluginManager: PluginManager<PluginHost & HOST, IPlugin<HOST, any>>;
+    use<P_1 extends IPlugin<HOST, any>>(plugin: P_1, ...options: FormatUsePluginParameters<P_1>): void | ReturnType<P_1["used"]>;
+};
+
+/**
+ * 创建带有选项机制的插件宿主类
+ * @remakers
+ * 比 直接使用 OptionsPluginHost 提供了完善的类型推导
+ *
+ * @returns
+ */
+export declare function createTierOptionsPluginHost<HOST, Options extends {}>(): {
+    new (options: Options): {
+        /**
+         * 实例级的默认选项
+         */
+        readonly defaultOptions: TierOptions<Options>;
+        _defaultOptions: TierOptions<Options>;
+        readonly pluginManager: PluginManager<any, IPlugin<any, any>>;
+        use<P extends IPlugin<HOST, any>>(plugin: P, ...options: FormatUsePluginParameters<P>): void | PluginCreatedReturnType<P>;
+        destroy(): void;
+    };
+    /**
+     * 全局级别的默认选项
+     */
+    readonly defaultOptions: TierOptions<Options>;
+    readonly pluginManager: PluginManager<PluginHost & HOST, IPlugin<HOST, any>>;
+    _pluginManager: PluginManager<PluginHost & HOST, IPlugin<HOST, any>>;
+    use<P_1 extends IPlugin<HOST, any>>(plugin: P_1, ...options: FormatUsePluginParameters<P_1>): void | ReturnType<P_1["used"]>;
+};
+
+/**
+ * 定义扩展的类型便利函数
+ *
+ * @remarks
+ * 它会更改 ext 中方法的this指向为 cla & ext，不会真的执行扩展操作。
+ *
+ * 其中 ext._constructor  会被保存在 cla._constructors 属性中，它是一个数组。
+ *
+ * cla 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
+ *
+ * @param cla - 扩展的目标，用作 this 的类型
+ * @param ext - 描述扩展内容的对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function defineExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<C & E>;
+
+/**
+ * 定义扩展的类型便利函数
+ *
+ * @remarks
+ * 它会更改 ext 中方法的this指向为 cla & ext，不会真的执行扩展操作。
+ *
+ * 其中：
+ * - ext._constructor  会被保存在 cla._constructors 属性中，它是一个数组。
+ * - ext._init  会被保存在 cla._inits 属性中，它是一个数组。
+ *
+ * cla 需要：
+ * - 在自己的构建函数中逐个调用 cla._constructors 中的函数
+ * - 在自己的类似初始化`init()` 方法中逐个调用 cla._constructors 中的函数
+ *
+ * @param cla - 扩展的目标，用作 this 的类型
+ * @param ext - 描述扩展内容的对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function defineExtendWithInit<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtendWithInit<C>): E & ThisType<C & E>;
+
+/**
+ * 定义混合的类型便利函数
+ *
+ * @remarks
+ * 它会更改 mixin 中方法的this指向为 target & mixin，不会真的执行混合操作
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @param mixin - 混合对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 mixin 对象本身
+ */
+export declare function defineMixin<T, M>(target: T, mixin: M & ThisType<T & M>): M & ThisType<T & M>;
+
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 会执行对 CEarth 类的扩展操作。
+ * 与 {@link targetExtend} 的区别仅仅是返回类型不一样。
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展对象，会自动更改其this的类型
+ * @returns 返回扩展后的 cla 对象
+ */
+export declare function extendTarget<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 会执行对 CEarth 类的扩展操作。
+ * 与 {@link targetExtendWithInit} 的区别仅仅是返回类型不一样。
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展对象，会自动更改其this的类型
+ * @returns 返回扩展后的 cla 对象
+ */
+export declare function extendTargetWithInit<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtendWithInit<C>): ClassType<ConstructorParameters<C>, E & ThisType<InstanceType<C> & E>>;
+
+/**
+ * 格式化 use 方法的参数列表
+ */
+export declare type FormatUseParameters<Options> = Options extends never | void | undefined ? [] : [Options];
+
+/**
+ * 格式化 use 方法的参数列表
+ */
+export declare type FormatUsePluginParameters<Plugin> = GetPluginOptions<Plugin> extends never | void | undefined ? [] : [GetPluginOptions<Plugin>];
+
+/**
+ * 获取规范化的插件选项
+ */
+export declare type GetNormalizePluginOptions<Plugin> = NormalizePluginOptions<GetPluginOptions<Plugin>>;
+
+/**
+ * 获取插件的选项类型
+ */
+export declare type GetPluginOptions<Plugin> = Plugin extends IPlugin<any, infer Options> ? Options : never;
+
+/**
+ * 通过key列表获取对象中对应属性的值
+ * @param obj
+ * @param props
+ * @returns
+ */
+export declare function getPropertyValue(obj: any, props: string[]): any;
+
+/**
+ * 获取对象的属性路径对应的属性值
+ * @param obj
+ * @param propPath
+ * @returns
+ */
+export declare function getPropertyValueByPath(obj: any, propPath: string): any;
+
+/**
+ * 按照 props 的结构，获取 target 的 属性对象
+ * - props 中所有 纯对象 都会被作为 props 进行递归地获取
+ * @param target
+ * @param props
+ * @returns
+ */
+export declare function getTargetProperties<Props>(target: any, props: Props): Props;
+
+/**
+ * 插件宿主的实例类型
+ */
+export declare type HostInst<H> = H extends new (...args: any) => any ? InstanceType<H> : H;
+
+/**
+ * 默认选项宿主接口
+ */
+export declare interface IDefaultOptionsHost<Options> {
+    readonly defaultOptions: Options;
+}
+
+/**
+ * 默认选项宿主的构建函数接口
+ */
+export declare interface IIDefaultOptionsHostConstructor<Options> {
+    get defaultOptions(): Options;
+}
+
+/**
+ * 插件的接口
+ *
+ * @typeParam HOST - 插件宿主的类类型
+ * @typeParam Options - 插件的选项类型
+ */
+export declare interface IPlugin<HOST, Options = void> {
+    /**
+     * 当插件被注册时调用
+     * @param Host - 宿主的类型
+     * @param options - 注册插件时的选项
+     */
+    used(Host: HOST, ...options: FormatUseParameters<Options>): any;
+    /**
+     * 当宿主实例被创建时调用
+     * @param host - 新建的宿主实例
+     * @param options - 注册插件时的选项
+     */
+    created?(host: HostInst<HOST>, ...options: FormatUseParameters<Options>): any;
+    /**
+     * 当宿主实例被销毁时调用
+     * @param host - 被销毁的宿主实例
+     * @param options - 注册插件时的选项
+     */
+    destroyed?(host: HostInst<HOST>, ...options: FormatUseParameters<Options>): any;
+}
+
+/**
+ * 插件宿主的接口
+ *
+ * @typeParam HostClassType 插件宿主类的类型
+ */
+export declare interface IPluginHost<HostClassType extends IPluginHostConstructor<any, Plugin>, Plugin extends IPlugin<HostClassType, any> = IPlugin<HostClassType, any>> {
+    /**
+     * PluginHost 的插件管理器
+     */
+    get pluginManager(): HostClassType["pluginManager"];
+    /**
+     * 实例的注册插件的方法
+     * @param plugin
+     * @param options
+     * @returns
+     */
+    use<P extends Plugin>(plugin: P, options: GetNormalizePluginOptions<P>): PluginCreatedReturnType<P> | void;
+}
+
+/**
+ * 插件宿主构造函数的接口
+ * @typeParam HostClassType 插件宿主类的类型
+ */
+export declare interface IPluginHostConstructor<HostClassType, Plugin extends IPlugin<HostClassType, any> = IPlugin<HostClassType, any>> {
+    /**
+     * PluginHost 的插件管理器
+     */
+    get pluginManager(): PluginManager<HostClassType, Plugin>;
+    /**
+     * {@inheritDoc PluginManager.use}
+     */
+    use<P extends Plugin>(plugin: P, options: GetNormalizePluginOptions<P>): PluginUseReturnType<P> | void;
+}
+
+/**
+ * 插件的接口
+ *
+ * @typeParam HOST - 插件宿主的类类型
+ * @typeParam Options - 插件的选项类型
+ */
+export declare interface IPluginWithInit<HOST, Options = void> extends IPlugin<HOST, Options> {
+    /**
+     * 当宿主实例被初始化时调用
+     * @param host - 新建的宿主实例
+     * @param options - 注册插件时的选项
+     */
+    inited?(host: HostInst<HOST>, ...options: FormatUseParameters<Options>): any;
+}
+
+/**
+ * 选项宿主接口
+ */
+export declare interface ITierModeOptionsHost<Options extends {} = any, Mode extends string | number = string> {
+    readonly modeOptions: TierModeOptions<Mode, Options>;
+    mode: Mode;
+    get options(): Options;
+}
+
+/**
+ * 选项宿主的构建函数接口
+ */
+export declare interface ITierModeOptionsHostConstructor<Options extends {} = any, Mode extends string | number = string> {
+    get modeOptions(): TierModeOptions<Mode, Options>;
+}
+
+/**
+ * 选项插件宿主接口
+ */
+export declare type ITierModeOptionsPluginHost<HostClassType extends ITierModeOptionsPluginHostConstructor<any>, Options extends {} = any, Mode extends string | number = string> = IPluginHost<HostClassType> & ITierModeOptionsHost<Options, Mode>;
+
+/**
+ * 选项插件宿主的构建函数接口
+ */
+export declare type ITierModeOptionsPluginHostConstructor<HostClassType, Options extends {} = any, Mode extends string | number = string> = IPluginHostConstructor<HostClassType> & ITierModeOptionsHostConstructor<Options, Mode>;
+
+/**
+ * 选项插件宿主接口
+ */
+export declare interface ITierOptionsHost<Options extends {} = any> {
+    readonly defaultOptions: TierOptions<Options>;
+}
+
+/**
+ * 选项插件宿主的构建函数接口
+ */
+export declare interface ITierOptionsHostConstructor<Options extends {} = any> {
+    get defaultOptions(): TierOptions<Options>;
+}
+
+/**
+ * 选项插件宿主接口
+ */
+export declare type ITierOptionsPluginHost<HostClassType extends ITierOptionsPluginHostConstructor<any>, Options extends {} = any> = IPluginHost<HostClassType> & ITierOptionsHost<Options>;
+
+/**
+ * 选项插件宿主的构建函数接口
+ */
+export declare type ITierOptionsPluginHostConstructor<HostClassType, Options extends {} = any> = IPluginHostConstructor<HostClassType> & ITierOptionsHostConstructor<Options>;
+
+/**
+ * 合并属性
+ * 该方法会将 props 深度合并到 target 中，
+ * - 所有 纯对象 的属性值都会被作为 props 进行深度合并
+ * - 对于不是纯对象的属性，会将其视为属性值设置到到目标中对应的属性上
+ *
+ * @param target
+ * @param props
+ */
+export declare function mergeProperties(target: any, props: any): any;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S>(target: T, source: S): T & S;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2>(target: T, source1: S1, source2: S2): T & S1 & S2;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2, S3>(target: T, source1: S1, source2: S2, source3: S3): T & S1 & S2 & S3;
+
+/**
+ * 混合
+ * @internal
+ */
+export declare function mixin<T, S1, S2, S3, S4>(target: T, source1: S1, source2: S2, source3: S3, source4: S3): T & S1 & S2 & S3 & S4;
+
+/**
+ * 混合
+ *
+ * @remarks
+ * 将 source 的所有成员混入 target 对象中。
+ *
+ * 与 `Object.assign()` 的功能类似，不同的是 `mixin()` 会在 target 对象中 保持 source 对象属性的  PropertyDescriptors
+ *
+ * @param target - 目标对象，所有 源对象 的属性都要被混入进到 目标对象中
+ * @param sources - 源对象，所有 源对象 的属性都要被混入进到 目标对象中
+ * @returns 混入后的 target
+ */
+export declare function mixin(target: any, ...sources: any[]): any;
+
+/**
+ * 混合目标
+ *
+ * @remarks
+ * 会执行对 CEarth 类的扩展操作。
+ * 与 {@link targetMixin} 的区别仅仅是返回类型不一样。
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @param m - 混合对象，会自动更改其this的类型
+ * @returns 返回混合后的 target 对象
+ */
+export declare function mixinTarget<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M> & T;
+
+/**
+ * 模式选项
+ * @remarks
+ * 针对选项提供了模式和继承的功能；
+ *
+ * 适用以下场景：
+ * 你设计了一个支持许多选项的工具，不同场景下需要配置不同的选项值，比如有如下几个场景：
+ * - 性能模式：所有的配置项以性能为目标进行配置，关闭那些效果类的选项；
+ * - 特效模式：以高质量的渲染效果为目标进行配置，会开启所有的效果选项；
+ * - 平衡模式：兼顾性能和效果，取个折中；
+ *
+ * 并且这些模式也会一些共同的选项；
+ *
+ * 使用该类，你可以：
+ * - 设置一个基本模式：该模式提供的所有模式都会有的共用选项
+ * - 设置 性能模式、特效模式、平衡模式 继承 基本模式；
+ */
+export declare class ModeOptions<Mode extends string | number = string, Option extends {} = any> extends OptionsManager<Option> {
+    constructor(mode: Mode);
+    constructor(mode: Mode, options?: Option);
+    /**
+     * 模式的配置
+     */
+    modes: Record<Mode, TierOptions<Option>>;
+    /**
+     * 当前模式
+     */
+    get mode(): Mode;
+    set mode(value: Mode);
+    protected _mode?: Mode;
+    /**
+     * 所有的模式名字
+     */
+    get modeNames(): Mode[];
+    protected _modeNames: Mode[] | null;
+    /**
+     * 获取所有的模式名字
+     * @returns
+     */
+    getModeNames(): Mode[];
+    /**
+     * 判断是否有某个模式
+     * @param mode
+     * @returns
+     */
+    hasMode(mode: string | number): boolean;
+    /**
+     * 当前模式的选项
+     */
+    get optionManager(): TierOptions<Option>;
+    /**
+     * 当前模式对应的选项
+     */
+    get option(): Option;
+    get plainFullOption(): Option;
+    protected _plainFullOption: Option | null;
+    /**
+     * 更新
+     */
+    updateFullOption(): void;
+    /**
+     * 返回已合并继承选项的选项
+     * @remarks
+     * 与继承选项只是浅合并
+     * @param mode
+     * @returns
+     */
+    getModeOption(mode: Mode): Option | null;
+    /**
+     * 返回已合并继承选项的完整选项
+     * @remarks
+     * 与继承选项合并
+     * @param mode
+     * @returns
+     */
+    getFullModeOption(mode: Mode): Option | null;
+    /**
+     * 给模式设置选项
+     * @param mode
+     * @param option
+     * @param deep - 是否要进行深度合并
+     * @param extend - 继承哪个模式
+     */
+    setModeOption(mode: Mode, option: Option, deep?: boolean, extend?: Mode): Record<Mode, TierOptions<Option>>[Mode];
+}
+
+/**
+ * 将选项格式成方法的参数类型
+ * @remarks
+ * 如果是 never|void|undefined 类型，则会被转为 void
+ */
+export declare type NormalizePluginOptions<Options> = Options extends never | void | undefined ? void : Options;
+
+/**
+ * 选项管理器
+ */
+declare abstract class OptionsManager<Option extends {} = any> {
+    /**
+     * 选项
+     */
+    abstract option: Option;
+    /**
+     * 是否要冻结 fullOption 的成员
+     * @remarks
+     * 只会冻结 fullOption 的直接成员的值，不会冻结 fullOption 孙子成员的值
+     */
+    freezeMember: boolean;
+    /**
+     * 可更新顶级成员值的完整的选项
+     * @remarks
+     * 合并后的选项；
+     * plainFullOption 的代理对象，自动监听了顶层成员的屐；所以可以更改顶级成员的值，不可以更改非顶级成员的值；
+     */
+    fullOption: Option;
+    /**
+     * 完整的选项
+     * @remarks
+     * 合并后的选项
+     */
+    abstract readonly plainFullOption: Option;
+    /**
+     * 更新完整的选项
+     */
+    abstract updateFullOption(): void;
+    /**
+     * 设置选项
+     * @remarks
+     * 会将被设置的选项浅合并进当前选项中
+     * @param option
+     * @param deep - 是否要进行深度合并
+     */
+    setOption(option: Option, deep?: boolean): void | Option;
+    /**
+     * 未定义值的类型
+     */
+    get undefinedValue(): UndefinedOptionValue;
+    set undefinedValue(value: UndefinedOptionValue);
+    protected _undefinedValue: UndefinedOptionValue;
+    /**
+     * 未定义值的判断函数
+     */
+    isUndefined: (value: any) => boolean;
+    /**
+     * 获取选项成员
+     * @param key
+     * @returns
+     */
+    getMember<Key extends keyof Option>(key: Key): Option[Key] | undefined | null;
+    /**
+     * 设置选项成员
+     * @param key
+     * @param value
+     * @param deep - 是否要进行深度合并
+     */
+    setMember<Key extends keyof Option>(key: Key, value?: Option[Key] | null, deep?: boolean): void;
+    /**
+     * 获取属性路径对应的值
+     * @param propPath
+     * @returns
+     */
+    getValue(propPath: string[]): any;
+    /**
+     * 设置属性路径对应的值
+     * @param propPath
+     * @param value
+     * @param deep - 是否要进行深度合并
+     * @returns
+     */
+    setValue(propPath: string[], value: any, deep?: boolean): void;
+}
+
+/**
+ * 解析属性路径为属性列表
+ * @param propPath
+ * @returns
+ */
+export declare function parsePropertyPath(propPath: string): string[];
+
+/**
+ * 插件的 created 方法的返回值类型
+ */
+export declare type PluginCreatedReturnType<P extends IPlugin<any, any>> = P["created"] extends AnyFunction ? ReturnType<P["created"]> : void;
+
+/**
+ * 插件的宿主
+ *
+ * @remarks
+ * 插件宿主 就是 拥有插件机制的宿主
+ *
+ * 子类需要在构建函数中调用 `this.pluginManager.created(this);`
+ *
+ * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+ * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+ */
+export declare class PluginHost<Plugin extends IPlugin<typeof PluginHost, any> = IPlugin<typeof PluginHost, any>> {
+    /**
+     * 插件管理器
+     */
+    static get pluginManager(): PluginManager<any, IPlugin<any, any>>;
+    protected static _pluginManager: PluginManager<any>;
+    /**
+     * 插件管理器 {@link PluginHost.pluginManager}
+     */
+    get pluginManager(): PluginManager<any, IPlugin<any, any>>;
+    /**
+     * {@inheritDoc PluginManager.use}
+     */
+    static use<Plugin extends IPlugin<typeof PluginHost, any>>(plugin: Plugin, ...options: FormatUsePluginParameters<Plugin>): void | ReturnType<Plugin["used"]>;
+    /**
+     * 需要在子类中调用
+     *
+     * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+     * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+     */
+    /**
+     * 实例的注册插件的方法
+     * @param plugin
+     * @param options
+     * @returns
+     */
+    use<P extends Plugin>(plugin: P, ...options: FormatUsePluginParameters<P>): PluginCreatedReturnType<P> | void;
+    /**
+     * 销毁实例
+     * @returns
+     */
+    destroy(): void;
+}
+
+/**
+ * 插件管理者
+ *
+ * @remarks
+ * 负责管理插件的注册、应用 等
+ *
+ * @typeParam HostClassType 插件宿主类的类型
+ *
+ */
+export declare class PluginManager<HostClassType, Plugin extends IPlugin<HostClassType, any> = IPlugin<HostClassType, any>> {
+    /**
+     * 插件的宿主
+     */
+    host: HostClassType;
+    /**
+     * 插件与插件选项的映射
+     */
+    readonly pluginOptsMap: Map<Plugin, any>;
+    /**
+     * 注册的插件
+     */
+    readonly plugins: Plugin[];
+    /**
+     * @param host - 插件的宿主
+     */
+    constructor(host?: HostClassType);
+    /**
+     * 使用插件、注册插件
+     * @param plugin - 插件
+     * @param options - 传递给插件的选项
+     */
+    use<P extends Plugin>(plugin: P, ...options: FormatUsePluginParameters<P>): PluginUseReturnType<P> | void;
+    /**
+     * 插件宿主创建实例时调用
+     *
+     * @remarks
+     * 会调用每个插件的 {@link IPlugin.created} 方法
+     * @param hostInst - 插件宿主的新实例
+     */
+    created(hostInst: HostInst<HostClassType>): void;
+    /**
+     * 插件宿主被销毁时调用
+     *
+     * @remarks
+     * 会调用每个插件的 {@link IPlugin.destroyed} 方法
+     * @param hostInst - 被销毁的插件实例
+     */
+    destroyed(hostInst: HostInst<HostClassType>): void;
+    /**
+     * 插件宿主实例的注册插件的方法
+     *
+     * @remarks
+     * 会调用每个插件的 {@link IPlugin.use | IPlugin.created()} 方法
+     * @param hostInst - 插件宿主的新实例
+     */
+    instUse<P extends Plugin>(hostInst: HostInst<HostClassType>, plugin: P, ...options: FormatUsePluginParameters<P>): PluginCreatedReturnType<P> | void;
+}
+
+/**
+ * 插件管理者
+ *
+ * @remarks
+ * 负责管理插件的注册、应用 等
+ *
+ * @typeParam HostClassType 插件宿主类的类型
+ *
+ */
+export declare class PluginManagerWithInit<HostClassType, Plugin extends IPluginWithInit<HostClassType, any> = IPluginWithInit<HostClassType, any>> extends PluginManager<HostClassType, Plugin> {
+    /**
+     * 插件宿主创建实例时调用
+     *
+     * @remarks
+     * 会调用每个插件的 {@link IPlugin.created | IPlugin.created()} 方法
+     * @param hostInst - 插件宿主的新实例
+     */
+    inited(hostInst: HostInst<HostClassType>): void;
+}
+
+/**
+ * 插件的 used 方法的返回值类型
+ */
+export declare type PluginUseReturnType<P extends IPlugin<any, any>> = ReturnType<P["used"]>;
+
+/**
+ * 用于定义扩展选项中的私有成员
+ */
+export declare interface PrivateMemberOfExtend<TargetType extends new (...args: any) => any> {
+    /**
+     * 扩展类中用于定义在创建实例时的初始化的方法
+     * @remarks
+     * 该方法会在创建实例时自动执行，并将构建函数接收到的参数透传给方方法。
+     *
+     * 注意：
+     * _constructor  会被保存在 目标类中的 _constructors 属性中，它是一个数组。
+     *
+     * 目标类 需要在自己的构建函数中逐个调用 cla._constructors 中的函数
+     *
+     * @param args
+     */
+    _constructor?(...args: (TargetType extends new (...args: infer A) => any ? A : never)): void;
+    /**
+     * 扩展类中用于定义在实例销毁时触发的销毁方法
+     * @remarks
+     * 该方法会在实例销毁时自动调用
+     *
+     * 注意：
+     * _destroy  会被保存在 目标类中的 _destroys 属性中，它是一个数组。
+     *
+     * 如果目标类有销毁逻辑，则需要在自己的销毁函数中逐个调用 cla._destroys 中的函数
+     *
+     * @param args
+     */
+    _destroy?(): void;
+}
+
+/**
+ * 用于定义扩展选项中的私有成员
+ */
+export declare interface PrivateMemberOfExtendWithInit<TargetType extends new (...args: any) => any, InitParams extends any[] = any> extends PrivateMemberOfExtend<TargetType> {
+    /**
+     * 扩展类中用于定义实例初始化逻辑的方法
+     * @remarks
+     * 该方法会在调用实例的 `init()` 方法时自动执行。
+     * @param args
+     */
+    _init?(...args: InitParams): void;
+}
+
+/**
+ * 替换构建函数的参数
+ */
+export declare type ReplaceConstructorParameters<C extends new (...args: any) => any, NewParms extends any[]> = new (...args: NewParms) => InstanceType<C>;
+
+/**
+ * 替换构造函数的返回类型
+ */
+export declare type ReplaceConstructorReturn<C extends new (...args: any) => any, NewReturn> = new (...args: ConstructorParameters<C>) => NewReturn;
+
+/**
+ * 通过属性路径列表设置对象中对应属性的值
+ * @param obj
+ * @param props
+ * @returns
+ */
+export declare function setPropertyValue(obj: any, props: string[], value: any): any;
+
+/**
+ * 获取对象的属性路径对应的属性值
+ * @param obj
+ * @param propPath
+ * @returns
+ */
+export declare function setPropertyValueByPath(obj: any, propPath: string, value: any): any;
+
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 与 {@link defineExtend} 的区别是：`targetExtend` 会执行对 cla 的扩展操作，而 {@link defineExtend} 不会
+ *
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展描述对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function targetExtend<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtend<C>): E & ThisType<InstanceType<C> & E>;
+
+/**
+ * 扩展目标
+ *
+ * @remarks
+ * 与 {@link defineExtendWithInit} 的区别是：`targetExtend` 会执行对 cla 的扩展操作，而 {@link defineExtendWithInit} 不会
+ *
+ *
+ * @param cla - 扩展的目标，也用作 this 的类型
+ * @param ext - 扩展描述对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 ext 对象本身
+ */
+export declare function targetExtendWithInit<C extends ClassType, E>(cla: C, ext: E & ThisType<InstanceType<C> & E> & PrivateMemberOfExtendWithInit<C>): E & ThisType<InstanceType<C> & E>;
+
+/**
+ * 混合目标
+ *
+ * @remarks
+ * 与 {@link defineMixin} 的区别是：`targetMixin` 会执行对 target 的混合操作，而 {@link defineMixin} 不会
+ *
+ *
+ * @param target - 混合的目标，用作 this 的类型
+ * @param m - 混合对象，会自动更改其this的类型
+ * @returns 返回注入了 this 类型的 mixin 对象本身
+ */
+export declare function targetMixin<T, M>(target: T, m: M & ThisType<T & M>): M & ThisType<T & M>;
+
+/**
+ * 层级模式选项
+ * @remarks
+ * 即 ModeOptions 和 TierOptions 的结合
+ */
+export declare class TierModeOptions<Mode extends string | number = string, Option extends {} = any> extends ModeOptions<Mode, Option> {
+    constructor(mode: Mode);
+    constructor(mode: Mode, options?: Option, extend?: TierModeOptions<Mode, Option>);
+    /**
+     * 继承的选项
+     */
+    get extends(): TierModeOptions<Mode, Option> | null;
+    set extends(value: TierModeOptions<Mode, Option> | null);
+    protected _extends: TierModeOptions<Mode, Option> | null;
+    /**
+     * 返回已合并继承选项的最终选项
+     * @remarks
+     * 与继承选项只是浅合并
+     * @param mode
+     * @returns
+     */
+    getFullModeOption(mode: Mode): Option | null;
+    /**
+     * 获取所有的模式名字
+     * @returns
+     */
+    getModeNames(): Mode[];
+    /**
+     * 在整个层级上判断是否有某个模式
+     * @param mode
+     * @returns
+     */
+    hasModeOnTier(mode: string | number): boolean;
+    /**
+     * 当前模式的选项
+     */
+    get optionManager(): TierOptions<Option>;
+    /**
+     * 获取模式对应的选项管理器
+     * @param mode
+     * @returns
+     */
+    getModeOptionManager(mode: Mode): TierOptions<Option> | null;
+    /**
+     * 获取选项成员
+     * @param key
+     * @returns
+     */
+    getMember<Key extends keyof Option>(key: Key): Option[Key] | undefined | null;
+    /**
+     * 获取属性路径对应的值
+     * @param propPath
+     * @returns
+     */
+    getValue(propPath: string[]): any;
+}
+
+/**
+ * 层级模式选项主机装饰器
+ * @remarks
+ * 可让宿主具备层级模式选项；
+ * 需要宿主有静态的同名属性；
+ * @param target
+ * @param context
+ * @returns
+ */
+export declare function tierModeOptionsDecorator<This, Value>(value: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>): ClassAccessorDecoratorResult<This, Value>;
+
+/**
+ * 层级模式选项插件的宿主
+ * @remarks
+ *
+ * 子类需要在构建函数中调用 `this.pluginManager.created(this);`
+ *
+ * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+ * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+ */
+export declare class TierModeOptionsPluginHost<Options extends {} = any, Mode extends string | number = string> extends PluginHost {
+    /**
+     * 全局级别的默认选项
+     */
+    static readonly modeOptions: TierModeOptions<string, any>;
+    /**
+     * 实例级的默认选项
+     */
+    get modeOptions(): TierModeOptions<Mode, Options>;
+    protected _modeOptions: TierModeOptions<Mode, Options>;
+    get mode(): Mode;
+    set mode(value: Mode);
+    get options(): Options;
+    constructor(options: Options);
+}
+
+export declare class TierOptions<Option extends {} = any> extends OptionsManager<Option> {
+    constructor(option?: Option, extend?: TierOptions<Option>);
+    /**
+     * 继承的选项
+     */
+    get extends(): TierOptions<Option> | null;
+    set extends(value: TierOptions<Option> | null);
+    protected _extends: TierOptions<Option> | null;
+    /**
+     * 选项
+     */
+    option: Option;
+    /**
+     * 获取完整的选项
+     * @remarks
+     * 会与继承来的选项进行合并
+     */
+    get plainFullOption(): Option;
+    protected _plainFullOption: Option | null;
+    /**
+     * 更新
+     */
+    updateFullOption(): void;
+    /**
+     * 获取选项成员
+     * @param key
+     * @returns
+     */
+    getMember<Key extends keyof Option>(key: Key): Option[Key] | undefined | null;
+    /**
+     * 获取属性路径对应的值
+     * @param propPath
+     * @returns
+     */
+    getValue(propPath: string[]): any;
+}
+
+/**
+ * 层级选项主机装饰器
+ * @remarks
+ * 可让宿主具备层级选项；
+ * 需要宿主有静态的同名属性；
+ * @param target
+ * @param context
+ * @returns
+ */
+export declare function tierOptionsDecorator<This, Value>(value: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>): ClassAccessorDecoratorResult<This, Value>;
+
+/**
+ * 层级选项插件的宿主
+ * @remarks
+ *
+ * 子类需要在构建函数中调用 `this.pluginManager.created(this);`
+ *
+ * 之所以没写在该类中的函数中，是因为 `this.pluginManager.created(this)` 通常会在构建函数执行的最后时才调用；
+ * 如果像下面写在该类的构建函数中，然后子类通过 `super()` 来调用，这样就会导致 `this.pluginManager.created(this)` 不是在最后的执行；
+ */
+export declare class TierOptionsPluginHost<Options extends {} = any> extends PluginHost {
+    /**
+     * 全局级别的默认选项
+     */
+    static readonly defaultOptions: TierOptions<any>;
+    /**
+     * 实例级的默认选项
+     */
+    get defaultOptions(): TierOptions<Options>;
+    protected _defaultOptions: TierOptions<Options>;
+    constructor(options: Options);
+}
+
+/**
+ * 视为未定义的选项值
+ * @remarks
+ * 当选项的值是未定义的值
+ */
+declare enum UndefinedOptionValue {
+    /**
+     * 将 undefined 和 null 都视为未定义的选项
+     */
+    UndefinedAndNull = "UndefinedAndNull",
+    /**
+     * 只将 undefined 视为未定义的选项
+     */
+    Undefined = "Undefined",
+    /**
+     * 只将 null 视为未定义的选项
+     */
+    Null = "Null"
+}
+
+export { }