ts-ref-kit 1.1.27 → 1.2.0

package/types/reflect-types/ClassDefinition.d.ts

@@ -4,6 +4,7 @@ import type { GenericProperty } from './PropertyDefinition';
 import { PropertyDefinition } from './PropertyDefinition';
 import { type Implementation } from './InterfaceDefinition';
 import { type TypeDefinition } from './TypeDefinition';
+import { ReflectContext } from './ReflectContext';
 export declare class ClassDefinition {
     readonly generics: string[];
     readonly name: string;
@@ -14,12 +15,13 @@ export declare class ClassDefinition {
     readonly properties: PropertyDefinition[];
     readonly fromLib: boolean;
     readonly jsClass?: Constructor;
+    private readonly context;
     private readonly _implementationNames;
     private readonly _implementations?;
     private _allImplementations?;
     constructor(def: RawClassDefinition & {
         jsClass?: Constructor;
-    });
+    }, context?: ReflectContext);
     get allMethods(): Dictionary<MethodDefinition>;
     get allProperties(): Dictionary<PropertyDefinition>;
     get implementations(): Implementation[];
@@ -39,5 +41,9 @@ export declare class GenericClass extends ClassDefinition {
     static create(proto: ClassDefinition, genericArgs: TypeDefinition[]): GenericClass;
     buildGenericContext(): void;
 }
-export declare function getClassByName(className: string): Constructor | undefined;
-export declare function getClassDefinition(arg: Constructor | object | string): ClassDefinition | undefined;
+declare module './ReflectContext' {
+    interface ReflectContext {
+        getClassByName(className: string): Constructor | undefined;
+        getClassDefinition(arg: Constructor | object | string): ClassDefinition | undefined;
+    }
+}

package/types/reflect-types/EnumDefinition.d.ts

@@ -1,4 +1,4 @@
-import { type RawEnumDefinition } from '../raw';
+import type { RawEnumDefinition } from '../raw';
 import { type TypeDefinition } from './TypeDefinition';
 export declare class EnumDefinition {
     readonly name: string;
@@ -8,8 +8,12 @@ export declare class EnumDefinition {
     get type(): TypeDefinition;
     get names(): string[];
 }
-export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
-export declare function getEnumNames(enumName: string): string[];
-export declare function getEnumValues(args: {
-    [enumName: string]: Record<string, string | number>;
-}): (string | number)[];
+declare module './ReflectContext' {
+    interface ReflectContext {
+        getEnumDefinition(name: string): EnumDefinition | undefined;
+        getEnumNames(enumName: string): string[];
+        getEnumValues(args: {
+            [enumName: string]: Record<string, string | number>;
+        }): (string | number)[];
+    }
+}

package/types/reflect-types/InterfaceDefinition.d.ts

@@ -2,6 +2,7 @@ import type { Dictionary, RawInterfaceDefinition } from '../raw';
 import type { MethodDefinition } from './MethodDefinition';
 import { PropertyDefinition } from './PropertyDefinition';
 import { type TypeDefinition } from './TypeDefinition';
+import { ReflectContext } from './ReflectContext';
 export type Implementation = InterfaceDefinition | TypeDefinition;
 export declare class InterfaceDefinition {
     readonly generics: string[];
@@ -12,7 +13,8 @@ export declare class InterfaceDefinition {
     private _implementations?;
     private _allImplementations?;
     readonly fromLib: boolean;
-    constructor(def: RawInterfaceDefinition);
+    private readonly context;
+    constructor(def: RawInterfaceDefinition, context?: ReflectContext);
     get implementations(): Implementation[];
     get allImplementations(): Implementation[];
     get type(): TypeDefinition;
@@ -26,4 +28,8 @@ export declare class GenericInterface extends InterfaceDefinition {
     static create(proto: InterfaceDefinition, genericArgs: TypeDefinition[]): GenericInterface;
     buildGenericContext(): void;
 }
-export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+declare module './ReflectContext' {
+    interface ReflectContext {
+        getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+    }
+}

package/types/reflect-types/MethodDefinition.d.ts

@@ -1,9 +1,11 @@
 import { type Dictionary, type RawMethodDefinition } from '../raw';
 import { type TypeDefinition } from './TypeDefinition';
 import { type MethodArg } from './package';
+import { type ReflectContext } from './ReflectContext';
 export declare class MethodDefinition {
     protected rawDef: RawMethodDefinition;
-    constructor(def: RawMethodDefinition);
+    protected readonly context: ReflectContext;
+    constructor(def: RawMethodDefinition, context?: ReflectContext);
     get name(): string;
     get returnType(): TypeDefinition;
     get args(): MethodArg[];
@@ -12,7 +14,7 @@ export declare class MethodDefinition {
     get isAsync(): boolean;
     get isConstructor(): boolean;
 }
-export declare function fillMethod(rawMethod: RawMethodDefinition): MethodDefinition;
+export declare function fillMethod(rawMethod: RawMethodDefinition, context?: ReflectContext): MethodDefinition;
 export declare class GenericMethod extends MethodDefinition {
     genericContext: Dictionary<TypeDefinition>;
     static create(proto: MethodDefinition, genericContext: Dictionary<TypeDefinition>): GenericMethod;

package/types/reflect-types/PropertyDefinition.d.ts

@@ -1,6 +1,7 @@
 import type { RawTypeDef } from '../raw';
 import { type Dictionary, type RawPropertyDefinition } from '../raw';
 import { type TypeDefinition } from './TypeDefinition';
+import { type ReflectContext } from './ReflectContext';
 type PropertyAccessor = {
     getter?: {
         isPrivate: boolean;
@@ -22,9 +23,10 @@ export declare class PropertyDefinition implements IPropertyDefinition {
     readonly isStatic: boolean;
     readonly accessor?: PropertyAccessor;
     readonly rawType?: RawTypeDef;
-    constructor(def: RawPropertyDefinition);
+    protected readonly context: ReflectContext;
+    constructor(def: RawPropertyDefinition, context?: ReflectContext);
     get type(): TypeDefinition;
-    static from(rawProperty: RawPropertyDefinition): PropertyDefinition;
+    static from(rawProperty: RawPropertyDefinition, context?: ReflectContext): PropertyDefinition;
 }
 export declare class GenericProperty extends PropertyDefinition {
     genericContext: Dictionary<TypeDefinition>;

package/types/reflect-types/ReflectContext.d.ts

@@ -0,0 +1,19 @@
+import { type RawTypeAliasDefinition } from '../raw';
+import type { ClassDefinition } from './ClassDefinition';
+import type { EnumDefinition } from './EnumDefinition';
+import type { InterfaceDefinition } from './InterfaceDefinition';
+export interface InstanceStore {
+    classMap: Map<string, ClassDefinition>;
+    interfaceMap: Map<string, InterfaceDefinition>;
+    enumMap: Map<string, EnumDefinition>;
+    typeAliasMap: Map<string, RawTypeAliasDefinition>;
+}
+export declare function setDefaultReflectModuleName(moduleName: string): void;
+export declare function getDefaultReflectModuleName(): string;
+export declare class ReflectContext {
+    readonly moduleName: string;
+    private readonly _instanceStore;
+    constructor(moduleName?: string);
+    get instanceStore(): InstanceStore;
+}
+export declare function getReflectContext(moduleName?: string): ReflectContext;

package/types/reflect-types/ReflectModule.d.ts

@@ -0,0 +1,57 @@
+import type { Constructor } from '../raw';
+import './ClassDefinition';
+import './EnumDefinition';
+import './InterfaceDefinition';
+import './TypeAliasDefinition';
+import './TypeDefinition';
+import './json';
+import './raw-meta';
+import './validates';
+import type { ClassDefinition } from './ClassDefinition';
+import type { EnumDefinition } from './EnumDefinition';
+import type { InterfaceDefinition } from './InterfaceDefinition';
+import type { JSONError, JSONTransfer } from './json';
+import type { RawReflectMeta } from '../raw';
+import type { TypeAliasDefinition } from './TypeAliasDefinition';
+import type { TypeDefinition } from './TypeDefinition';
+import type { Type, ValidateResult } from './validates';
+import { type InstanceStore, type ReflectContext } from './ReflectContext';
+import type { ReflectConfig } from './index';
+export declare class ReflectModule {
+    private readonly context;
+    constructor(context: ReflectContext);
+    get name(): string;
+    get ReflectClass(): ClassDecorator;
+    get ReflectValidate(): MethodDecorator;
+    get json(): JSONTransfer;
+    createJSONTransfer(exceptionHandler?: (error: JSONError) => void): JSONTransfer;
+    registerClass(jsClass: Constructor): void;
+    getClassDefinition(arg: Constructor | object | string): ClassDefinition | undefined;
+    getClassByName(className: string): Constructor | undefined;
+    getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+    getTypeAliasDefinition(name: string, genericArgs?: TypeDefinition[]): TypeAliasDefinition | undefined;
+    getEnumDefinition(name: string): EnumDefinition | undefined;
+    getEnumNames(enumName: string): string[];
+    getEnumValues(args: {
+        [enumName: string]: Record<string, string | number>;
+    }): (string | number)[];
+    getTypeDefinition(typeName: string, genericArgs?: TypeDefinition[]): TypeDefinition;
+    getTypeDef(type: Type | TypeDefinition): TypeDefinition;
+    assertType<T>(data: unknown, type: Type, depth?: number): T;
+    isNullable(type: Type | TypeDefinition): boolean;
+    isType(value: unknown, type: Type | TypeDefinition, depth?: number): boolean;
+    validateValue(value: unknown, typeDef: TypeDefinition, depth?: number): ValidateResult;
+    validateInstance<T extends object>(instance: T, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+    validateArray<T extends object>(array: T[], type?: Type | TypeDefinition, depth?: number): ValidateResult;
+    validateDictionary<T extends object>(dict: {
+        [key: string]: T;
+    }, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+    safeSetValue(target: object, propName: string, value: unknown): void;
+    safeCall<R>(target: object, methodName: string, ...args: unknown[]): R | undefined;
+    getDebugInfo(): {
+        raw: RawReflectMeta;
+        instances: InstanceStore;
+        config: typeof ReflectConfig;
+    } | undefined;
+}
+export declare function getReflectModule(name?: string): ReflectModule;

package/types/reflect-types/TypeAliasDefinition.d.ts

@@ -5,4 +5,8 @@ export interface TypeAliasDefinition {
     type: TypeDefinition;
     fromLib: boolean;
 }
-export declare function getTypeAliasDefinition(name: string, genericArgs?: TypeDefinition[]): TypeAliasDefinition | undefined;
+declare module './ReflectContext' {
+    interface ReflectContext {
+        getTypeAliasDefinition(name: string, genericArgs?: TypeDefinition[]): TypeAliasDefinition | undefined;
+    }
+}

package/types/reflect-types/TypeDefinition.d.ts

@@ -68,12 +68,16 @@ export declare function isIndexType(type: TypeDefinition): type is {
         valueType: TypeDefinition;
     };
 };
-export declare function getTypeDefinition(typeName: string, genericArgs?: TypeDefinition[]): TypeDefinition;
-export declare function fillType(args: {
-    rawType: RawTypeDefinition | string | undefined;
-    genericContext?: Dictionary<TypeDefinition>;
-    genericArgs?: TypeDefinition[];
-}): TypeDefinition;
+declare module './ReflectContext' {
+    interface ReflectContext {
+        getTypeDefinition(typeName: string, genericArgs?: TypeDefinition[]): TypeDefinition;
+        fillType(args: {
+            rawType: RawTypeDefinition | string | undefined;
+            genericContext?: Dictionary<TypeDefinition>;
+            genericArgs?: TypeDefinition[];
+        }): TypeDefinition;
+    }
+}
 export declare const TypeDefinition: {
     isPrimitiveType: typeof isPrimitiveType;
     isArrayType: typeof isArrayType;

package/types/reflect-types/compat.d.ts

@@ -0,0 +1,44 @@
+import type { Constructor, RawReflectMeta, RawTypeDefinition } from '../raw';
+import type { Dictionary } from '../raw';
+import type { ClassDefinition } from './ClassDefinition';
+import type { EnumDefinition } from './EnumDefinition';
+import { ReflectConfig } from './index';
+import type { InterfaceDefinition } from './InterfaceDefinition';
+import type { TypeAliasDefinition } from './TypeAliasDefinition';
+import type { TypeDefinition } from './TypeDefinition';
+import type { InstanceStore } from './ReflectContext';
+import type { Type } from './validates/Type';
+import type { ValidateResult } from './validates/ValidateResult';
+export declare function setReflectModule(moduleName: string): void;
+export declare function getRawMeta(): RawReflectMeta | undefined;
+export declare function getDebugInfo(): {
+    raw: RawReflectMeta;
+    instances: InstanceStore;
+    config: typeof ReflectConfig;
+} | undefined;
+export declare function getClassByName(className: string): Constructor | undefined;
+export declare function getClassDefinition(arg: Constructor | object | string): ClassDefinition | undefined;
+export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+export declare function getTypeAliasDefinition(name: string, genericArgs?: TypeDefinition[]): TypeAliasDefinition | undefined;
+export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+export declare function getEnumNames(enumName: string): string[];
+export declare function getEnumValues(args: {
+    [enumName: string]: Record<string, string | number>;
+}): (string | number)[];
+export declare function getTypeDefinition(typeName: string, genericArgs?: TypeDefinition[]): TypeDefinition;
+export declare function fillType(args: {
+    rawType: RawTypeDefinition | string | undefined;
+    genericContext?: Dictionary<TypeDefinition>;
+    genericArgs?: TypeDefinition[];
+}): TypeDefinition;
+export declare function getTypeDef(type: Type | TypeDefinition): TypeDefinition;
+export declare function assertType<T>(data: unknown, type: Type, depth?: number): T;
+export declare function isNullable(type: Type | TypeDefinition): boolean;
+export declare function isType(value: unknown, type: Type | TypeDefinition, depth?: number): boolean;
+export declare function validateInstance<T extends object>(instance: T, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+export declare function validateArray<T extends object>(array: T[], type?: Type | TypeDefinition, depth?: number): ValidateResult;
+export declare function validateDictionary<T extends object>(dict: Dictionary<T>, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
+export declare function validateClassInstance<T extends object>(instance: T, typeDef: TypeDefinition, depth?: number): ValidateResult;
+export declare function safeSetValue(target: object, propName: string, value: unknown): void;
+export declare function safeCall<R>(target: object, methodName: string, ...args: unknown[]): R | undefined;

package/types/reflect-types/extension.d.ts

@@ -0,0 +1,5 @@
+type ExtensionClass<T extends object> = Function & {
+    prototype: T;
+};
+export declare function extension<T extends object>(base: ExtensionClass<T>, ext: ExtensionClass<T>): void;
+export {};

package/types/reflect-types/index.d.ts

@@ -1,13 +1,19 @@
 import type { ValidationError } from './validates';
-import type { RawReflectMeta } from '../raw';
-import { instanceStore } from './instance-store';
-export { reflectReady, setReflectModule } from './raw-meta';
+import './ClassDefinition';
+import './EnumDefinition';
+import './InterfaceDefinition';
+import './TypeAliasDefinition';
+import './TypeDefinition';
+export { reflectReady, ReflectClass } from './raw-meta';
+export { ReflectModule, getReflectModule } from './ReflectModule';
+export { ReflectContext, getReflectContext } from './ReflectContext';
+export { extension } from './extension';
+export { assertType, fillType, getClassByName, getClassDefinition, getDebugInfo, getEnumDefinition, getEnumNames, getEnumValues, getInterfaceDefinition, getRawMeta, getTypeAliasDefinition, getTypeDef, getTypeDefinition, isNullable, isType, safeCall, safeSetValue, setReflectModule, validateArray, validateClassInstance, validateDictionary, validateInstance, validateValue } from './compat';
 export { TypeDefinition } from './TypeDefinition';
-export { getClassDefinition, getClassByName, type ClassDefinition } from './ClassDefinition';
-export { getInterfaceDefinition, type InterfaceDefinition } from './InterfaceDefinition';
-export { getTypeAliasDefinition, type TypeAliasDefinition } from './TypeAliasDefinition';
-export { getEnumDefinition, getEnumNames, getEnumValues, type EnumDefinition } from './EnumDefinition';
-export { validateValue } from './validates/value-validate';
+export { type ClassDefinition } from './ClassDefinition';
+export { type InterfaceDefinition } from './InterfaceDefinition';
+export { type TypeAliasDefinition } from './TypeAliasDefinition';
+export { type EnumDefinition } from './EnumDefinition';
 export * from './json';
 export * from './validates';
 export { registerSpecialType } from './special-types';
@@ -19,8 +25,3 @@ export declare const ReflectConfig: {
     validation: boolean;
     debug: boolean;
 };
-export declare function getDebugInfo(): {
-    raw: RawReflectMeta;
-    instances: typeof instanceStore;
-    config: typeof ReflectConfig;
-} | undefined;

package/types/reflect-types/json/JSONTransfer.d.ts

@@ -1,11 +1,19 @@
 import type { JSONString } from './types';
 import { type Type } from '../validates';
+import { ReflectContext } from '../ReflectContext';
 export declare class JSONTransfer {
     exceptionHandler: (error: JSONError) => void;
-    constructor(exceptionHandler?: (error: JSONError) => void);
+    private readonly context;
+    constructor(exceptionHandler?: (error: JSONError) => void, context?: ReflectContext);
     parse<T = unknown>(jsonString: JSONString<T>, type?: Type): T;
     private convertJSONValue;
     private convertJSONObjectAsClassInstance;
 }
 export declare class JSONError extends Error {
 }
+declare module '../ReflectContext' {
+    interface ReflectContext {
+        readonly json: JSONTransfer;
+        createJSONTransfer(exceptionHandler?: (error: JSONError) => void): JSONTransfer;
+    }
+}

package/types/reflect-types/raw-meta.d.ts

@@ -1,5 +1,17 @@
-import type { RawReflectMeta } from '../raw';
+import type { Constructor, RawReflectMeta } from '../raw';
+import { ReflectConfig } from './index';
 export declare const reflectReady: Promise<void>;
-export declare function setReflectModule(moduleName: string): void;
-export declare function getRawMeta(): RawReflectMeta | undefined;
+export declare function createReflectClassDecorator(moduleName?: string): ClassDecorator;
 export declare const ReflectClass: ClassDecorator;
+declare module './ReflectContext' {
+    interface ReflectContext {
+        readonly ReflectClass: ClassDecorator;
+        registerClass(jsClass: Constructor): void;
+        getRawMeta(): RawReflectMeta | undefined;
+        getDebugInfo(): {
+            raw: RawReflectMeta;
+            instances: InstanceStore;
+            config: typeof ReflectConfig;
+        } | undefined;
+    }
+}

package/types/reflect-types/validates/Type.d.ts

@@ -1,4 +1,4 @@
-import { type TypeDefinition } from '../TypeDefinition';
+import type { TypeDefinition } from '../TypeDefinition';
 export type Type = string | {
     array: Type;
 } | {
@@ -11,9 +11,13 @@ export type Type = string | {
     name: string;
     generic: Type[];
 };
-export declare function getTypeDef(type: Type | TypeDefinition): TypeDefinition;
-export declare function assertType<T>(data: unknown, type: Type, depth?: number): T;
-export declare function isNullable(type: Type | TypeDefinition): boolean;
-export declare function isType(value: unknown, type: Type | TypeDefinition, depth?: number): boolean;
+declare module '../ReflectContext' {
+    interface ReflectContext {
+        getTypeDef(type: Type | TypeDefinition): TypeDefinition;
+        assertType<T>(data: unknown, type: Type, depth?: number): T;
+        isNullable(type: Type | TypeDefinition): boolean;
+        isType(value: unknown, type: Type | TypeDefinition, depth?: number): boolean;
+    }
+}
 export declare class TypeParseError extends Error {
 }

package/types/reflect-types/validates/index.d.ts

@@ -2,4 +2,4 @@ export * from './Type';
 export * from './ValidateResult';
 export * from './instance-validate';
 export * from './method-validate';
-export { safeSetValue } from './value-validate';
+export * from './value-validate';

package/types/reflect-types/validates/instance-validate.d.ts

@@ -1,7 +1,11 @@
 import type { Dictionary } from '../../raw';
 import type { ValidateResult } from './ValidateResult';
-import { type Type } from './Type';
+import type { Type } from './Type';
 import type { TypeDefinition } from '..';
-export declare function validateInstance<T extends object>(instance: T, type?: Type | TypeDefinition, depth?: number): ValidateResult;
-export declare function validateArray<T extends object>(array: T[], type?: Type | TypeDefinition, depth?: number): ValidateResult;
-export declare function validateDictionary<T extends object>(dict: Dictionary<T>, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+declare module '../ReflectContext' {
+    interface ReflectContext {
+        validateInstance<T extends object>(instance: T, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+        validateArray<T extends object>(array: T[], type?: Type | TypeDefinition, depth?: number): ValidateResult;
+        validateDictionary<T extends object>(dict: Dictionary<T>, type?: Type | TypeDefinition, depth?: number): ValidateResult;
+    }
+}

package/types/reflect-types/validates/method-validate.d.ts

@@ -5,5 +5,11 @@ declare global {
     }
 }
 export declare const ReflectValidate: MethodDecorator;
-export declare function safeCall<R>(target: object, methodName: string, ...args: unknown[]): R | undefined;
+export declare function createReflectValidate(reflectModule?: string): MethodDecorator;
+declare module '../ReflectContext' {
+    interface ReflectContext {
+        readonly ReflectValidate: MethodDecorator;
+        safeCall<R>(target: object, methodName: string, ...args: unknown[]): R | undefined;
+    }
+}
 export {};

package/types/reflect-types/validates/value-validate.d.ts

@@ -1,6 +1,28 @@
 import { type TypeDefinition } from '../TypeDefinition';
+import type { IPropertyDefinition } from '../PropertyDefinition';
 import type { ValidateResult } from './ValidateResult';
 export declare const preservedTypes: Function[];
-export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
-export declare function validateClassInstance<T extends object>(instance: T, typeDef: TypeDefinition, depth?: number): ValidateResult;
-export declare function safeSetValue(target: object, propName: string, value: unknown): void;
+declare module '../ReflectContext' {
+    interface ReflectContext {
+        validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
+        validateArrayValue(value: unknown, type: {
+            arrayElementType: TypeDefinition;
+        }, depth?: number): ValidateResult;
+        validateIndexedValue(value: unknown, type: {
+            index: {
+                keyType?: TypeDefinition;
+                valueType: TypeDefinition;
+            };
+        }, depth?: number): ValidateResult;
+        validateTupleValue(value: unknown, type: {
+            tupleMembers: TypeDefinition[];
+        }, depth?: number): ValidateResult;
+        validateProperties(value: unknown, type: {
+            typeLiteralMembers: IPropertyDefinition[];
+        }, depth?: number): ValidateResult;
+        validateSimpleValue(value: unknown, type: TypeDefinition | string, depth?: number): ValidateResult;
+        validateClassInstance<T extends object>(instance: T, typeDef: TypeDefinition, depth?: number): ValidateResult;
+        valueInstanceOf(value: object, className: string): boolean;
+        safeSetValue(target: object, propName: string, value: unknown): void;
+    }
+}

package/types/reflect-types/instance-store.d.ts

@@ -1,15 +0,0 @@
-import type { ClassDefinition } from './ClassDefinition';
-import type { InterfaceDefinition } from './InterfaceDefinition';
-import type { EnumDefinition } from './EnumDefinition';
-import type { RawTypeAliasDefinition } from '../raw';
-export declare const instanceStore: {
-    classMap: Map<string, ClassDefinition>;
-    interfaceMap: Map<string, InterfaceDefinition>;
-    enumMap: Map<string, EnumDefinition>;
-    typeAliasMap: Map<string, RawTypeAliasDefinition>;
-    invalidateClasses(names: string[]): void;
-    invalidateInterfaces(names: string[]): void;
-    invalidateEnums(names: string[]): void;
-    invalidateTypeAliases(names: string[]): void;
-    clear(): void;
-};