ts-ref-kit 1.0.15 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ref-kit",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Type reflection and validation library for TypeScript",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -14,36 +14,32 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": "./types/index.d.ts",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.cjs"
     },
     "./parser": {
-      "types": "./dist/types/parser/index.d.ts",
+      "types": "./types/parser/index.d.ts",
       "import": "./dist/esm/parser/index.js",
       "require": "./dist/cjs/parser/index.cjs"
     }
   },
   "typesVersions": {
     "*": {
-      "parser": [
-        "types/parser/index.d.ts"
-      ],
-      "*": [
-        "types/index.d.ts"
-      ]
+      "parser": ["types/parser/index.d.ts"],
+      "*": ["types/index.d.ts"]
     }
   },
   "scripts": {
-    "clean": "rimraf dist types",
-    "build": "npm run clean && node esbuild.config.js && node esbuild.parser.config.js && tsc --emitDeclarationOnly && api-extractor run --local --config api-extractor.json && api-extractor run --local --config api-extractor.parser.json && rimraf types"
+    "build-types": "tsc --emitDeclarationOnly --outDir types",
+    "clean": "rm -rf dist types",
+    "build": "npm run clean && node esbuild.config.js && node esbuild.parser.config.js && tsc --emitDeclarationOnly --outDir types"
   },
   "dependencies": {
     "reflect-metadata": "^0.2.2",
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.11",
     "@types/node": "^24.2.0",
     "esbuild": "^0.25.9",
     "rimraf": "^6.0.1",

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reflect-types';
+export * from './reflect-json';

package/types/parser/index.d.ts

@@ -0,0 +1,3 @@
+export * from './reflect-loader';
+export * from './reflect-parser-plugin';
+export * from './reflect-parser';

package/types/parser/path-match.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 检查文件路径是否匹配 glob 规则
+ * @param filePath 要检查的文件路径（绝对或相对路径）
+ * @param pattern glob 规则，如 `/src/**\/.ts`
+ * @returns 是否匹配
+ */
+export default function isPathMatch(filePath: string, pattern: string | string[]): boolean;

package/types/parser/reflect-loader.d.ts

@@ -0,0 +1,10 @@
+export interface ReflectLoaderOptions {
+    sourcePaths: string | string[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    forEnabledClassOnly?: boolean;
+    outputLog?: boolean;
+}
+export declare function reflectLoader(options: ReflectLoaderOptions): {
+    outputAllMetas: () => string;
+    transform: (sourceCode: string, sourceFileName: string) => string;
+};

package/types/parser/reflect-parser-plugin.d.ts

@@ -0,0 +1,7 @@
+import { type Plugin } from 'vite';
+import { ReflectLoaderOptions } from './reflect-loader';
+interface Options extends ReflectLoaderOptions {
+    entry: string;
+}
+export declare function reflectParserPlugin(options: Options): Plugin;
+export {};

package/{dist/types/parser/index.d.ts → types/parser/reflect-parser.d.ts}

@@ -1,110 +1,77 @@
-import { Plugin as Plugin_2 } from 'vite';
-
-declare type Any = any;
-
-export declare const DEBUG_CONFIG: {
-    OUTPUT_LOG: boolean;
-};
-
-declare type FilePathRule = string | RegExp | (string | RegExp)[];
-
-declare interface Options extends ReflectLoaderOptions {
-    entry: string;
-}
-
-export declare function parseSource(filePaths?: string | string[], exclude?: FilePathRule): {
-    classDefinitions: Map<string, RawClassDefinition>;
-    interfaceDefinitions: Map<string, RawInterfaceDefinition>;
-    enumDefinitions: Map<string, RawEnumDefinition>;
-    typeAliasDefinitions: Map<string, RawTypeDef>;
-    constTypeDefinitions: Map<string, RawTypeDef>;
-};
-
-export declare interface RawClassDefinition {
-    name: string;
-    superClassName?: string;
-    implementations?: string[];
-    methods?: RawMethodDefinition[];
-    properties?: RawPropertyDefinition[];
-}
-
-export declare interface RawEnumDefinition {
-    name: string;
-    members: {
-        name: string;
-        initializer: string | undefined;
-    }[];
-}
-
-export declare interface RawInterfaceDefinition {
-    name: string;
-    implementations?: string[];
-    methods?: RawMethodDefinition[];
-    properties?: RawPropertyDefinition[];
-    indexElementType?: RawTypeDef;
-}
-
-export declare interface RawMethodDefinition {
-    name: string;
-    isPrivate?: boolean;
-    isStatic?: boolean;
-    isAsync?: boolean;
-    returnType?: RawTypeDef;
-    args?: {
-        name: string;
-        type?: RawTypeDef;
-        isOptional: boolean;
-    }[];
-}
-
-export declare interface RawPropertyDefinition {
-    name: string;
-    isOptional?: boolean;
-    isPrivate?: boolean;
-    isStatic?: boolean;
-    type?: RawTypeDef;
-    accessor?: {
-        getter?: {
-            isPrivate: boolean;
-        };
-        setter?: {
-            isPrivate: boolean;
-        };
-    };
-}
-
-declare type RawTypeDef = string | RawTypeDefinition;
-
-export declare interface RawTypeDefinition {
-    arrayElementType?: RawTypeDef;
-    indexElementType?: RawTypeDef;
-    literalValue?: Any;
-    typeLiteralMembers?: RawPropertyDefinition[];
-    unionMembers?: RawTypeDef[];
-    intersectionMembers?: RawTypeDef[];
-    generics?: RawTypeDef[];
-    isFunction?: boolean;
-    tupleMembers?: RawTypeDef[];
-    isOptionalInTuple?: boolean;
-    isConstructor?: boolean;
-}
-
-export declare function reflectLoader(options: ReflectLoaderOptions): {
-    outputAllMetas: () => string;
-    transform: (sourceCode: string, sourceFileName: string) => string;
-};
-
-export declare interface ReflectLoaderOptions {
-    sourcePaths: string | string[];
-    exclude?: string | RegExp | (string | RegExp)[];
-    forEnabledClassOnly?: boolean;
-    outputLog?: boolean;
-}
-
-export declare function reflectParserPlugin(options: Options): Plugin_2;
-
-export declare function setupReflectTypes(filePaths: string | string[], exclude?: FilePathRule, distFolder?: string): Promise<void>;
-
-export declare function updateReflectModules(filePath: string, distFolder: string): Promise<void>;
-
-export { }
+export declare const DEBUG_CONFIG: {
+    OUTPUT_LOG: boolean;
+};
+type Any = any;
+export interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+    indexElementType?: RawTypeDef;
+}
+export interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+export interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+export interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+type RawTypeDef = string | RawTypeDefinition;
+export interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    indexElementType?: RawTypeDef;
+    literalValue?: Any;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    generics?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+}
+type FilePathRule = string | RegExp | (string | RegExp)[];
+export declare function setupReflectTypes(filePaths: string | string[], exclude?: FilePathRule, distFolder?: string): Promise<void>;
+export declare function updateReflectModules(filePath: string, distFolder: string): Promise<void>;
+export declare function parseSource(filePaths?: string | string[], exclude?: FilePathRule): {
+    classDefinitions: Map<string, RawClassDefinition>;
+    interfaceDefinitions: Map<string, RawInterfaceDefinition>;
+    enumDefinitions: Map<string, RawEnumDefinition>;
+    typeAliasDefinitions: Map<string, RawTypeDef>;
+    constTypeDefinitions: Map<string, RawTypeDef>;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import { type EnableReflect } from '../reflect-types';
+import type { Class, JsonValue } from './types';
+export interface Mappable extends EnableReflect {
+    mapping(map: Mapping<Mappable>): void;
+}
+export type Mapping<T extends Mappable> = {
+    [propName in keyof T]-?: (fieldName?: string | symbol, transform?: {
+        fromJSON?: (jsonValue: JsonValue) => Mappable;
+        toJSON?: (obj: Mappable) => JsonValue;
+    }) => void;
+};
+export declare function registerMappable<T extends Mappable>(mappableClass: Class<T>): void;
+export declare function mapAllProperties<T extends Mappable>(target: T, map: Mapping<T>): void;

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

@@ -0,0 +1,18 @@
+import { ReflectPropertyKey } from './reflect-extension';
+import type { Any } from './types';
+export declare function defineDecoratedProperty(metaKey: symbol): PropertyDecorator;
+export declare function callDecoratedMethod<Self extends object>(self: Self, metaKey: symbol, ...args: Any[]): Any | undefined;
+export declare function hasDecoratedMethod<Self extends object>(self: Self, metaKey: symbol): boolean;
+export declare function getDecoratedProperty(target: object, metaKey: symbol): ReflectPropertyKey | undefined;
+export declare function getDecoratedPropertyValue<V>(target: object, metaKey: symbol): V | undefined;
+export declare const PropertyWrapper: IPropertyWrapper;
+type IPropertyWrapper = {
+    getField: (owner: object, property: ReflectPropertyKey, fieldSymbol: symbol) => Any;
+    setField: (owner: object, property: ReflectPropertyKey, newValue: Any, fieldSymbol: symbol) => void;
+} & (<T>({ getter, setter, fieldSymbol }: {
+    getter?: (self: object, property: ReflectPropertyKey) => T;
+    setter?: (self: object, newValue: T, property: ReflectPropertyKey) => void;
+    fieldSymbol: symbol;
+}) => PropertyDecorator);
+export declare function Lazy(creator: (self: object, property: ReflectPropertyKey) => Any): PropertyDecorator;
+export {};

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

@@ -0,0 +1,6 @@
+export * from './Mappable';
+export * from './decorate';
+export * from './json-translation';
+export * from './reflect-extension';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,38 @@
+import 'reflect-metadata';
+import { Any, AnyObject, Class, ClassOrInstance, JsonObject, JsonValue } from './types';
+type FromJSON<T> = (jsonValue: JsonValue) => T;
+type ToJSON<T> = (obj: T) => JsonValue;
+type SerializedOptions<T> = {
+    name?: string;
+    class?: Class<T>;
+    fromJSON?: FromJSON<T>;
+    toJSON?: ToJSON<T>;
+};
+export declare function setDefaultIgnored(clazz: Class<Any>, defaultIgnored: boolean): void;
+export declare function registerSerializedProperty(target: AnyObject, propName: string, options: SerializedOptions<Any>): void;
+export declare const SerializedClass: PropertyDecorator;
+export declare function Serialized<T extends object>(options?: SerializedOptions<T>): PropertyDecorator;
+export declare function SerializedName(serializedName: string): PropertyDecorator;
+export declare const IgnoreSerialization: PropertyDecorator;
+/**
+ * serialize an object to json string
+ */
+export declare function serialize<T>(value: T): string;
+export declare function serializeTo<T>(value: T): JsonValue;
+/**
+ * convert an object to data object
+ */
+export declare function serializeToData<T extends object>(object: T): JsonObject | JsonObject[];
+export declare function deserialize<T>(json: string | JsonValue, constructorOrTarget?: ClassOrInstance<T>): T;
+export declare function deserializeArray<T>(json: string | JsonValue[], clazz?: Class<T>): T[];
+export declare function deserializeFrom<T extends AnyObject>(data: JsonObject, target: T): void;
+export declare function getSerializeSettings(clazz: Class<Any>): any;
+export interface JsonValueTransform<T> {
+    fromJson: FromJSON<T>;
+    toJson: ToJSON<T>;
+}
+export declare function registerTransform<T>(clazz: Class<T>, transform: JsonValueTransform<T>): void;
+export declare const itSelf: (some: Any) => any;
+export declare const done: () => any;
+export declare const AfterSerialized: PropertyDecorator;
+export {};

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

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+import { Any, AnyConstructorFunction, AnyObject, Optional } from './types';
+export type ReflectPropertyKey = string | symbol;
+export type ReflectType = StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | FunctionConstructor | AnyConstructorFunction;
+declare global {
+    namespace Reflect {
+        function getDesignType<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType>;
+        function getReturnType<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType>;
+        function getParamTypes<T extends AnyObject>(target: T, property: keyof T | ReflectPropertyKey): Optional<ReflectType[]>;
+        function addMetadataList<T extends object>(key: symbol, value: Any, target: T): void;
+        function addMetadataList<T extends object>(key: symbol, value: Any, target: T, property: ReflectPropertyKey): void;
+    }
+}

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

@@ -0,0 +1,15 @@
+export type Any = any;
+export type AnyFunction = (...args: Any[]) => Any;
+export type AnyConstructorFunction = new (...args: Any[]) => Any;
+export type Class<T> = new (...args: Any[]) => T;
+export type ClassOrInstance<T> = T | Class<T>;
+export type Dictionary<T> = {
+    [key: string | symbol]: T;
+};
+export type AnyObject = Dictionary<Any>;
+export type Optional<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type JsonValue = string | number | boolean | null | JsonObject | JsonObject[];
+export type JsonObject = {
+    [propName: string]: JsonValue;
+};

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

@@ -0,0 +1,9 @@
+import { Any, Class } from "./types";
+export declare function asBoolean(value: unknown): boolean;
+export declare function asString(v: unknown): string;
+export declare function asNumber(v: unknown): number;
+export declare function setAnyValue<T>(target: Any, field: string | number | symbol, value: T): void;
+export declare function getAnyValue<T>(target: Any, field: string | number | symbol): T | undefined;
+export declare function getOrSetValue<T>(target: Any, field: string | number | symbol, defaultWith: () => T): T;
+export declare function isDictionary(value: Any): boolean;
+export declare function createNewInstance<T>(clazz: Class<T>): any;

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

@@ -0,0 +1,28 @@
+import { RawClassDefinition, TypeDefinition } from './index';
+import { InterfaceDefinition, MethodDefinition, PropertyDefinition } from './index';
+import type { AnyConstructorFunction, Dictionary } from './package';
+type ImplementationOfClass = InterfaceDefinition | TypeDefinition;
+export declare class ClassDefinition {
+    readonly name: string;
+    readonly superClassName: string;
+    readonly superClass: ClassDefinition | undefined;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition[];
+    readonly jsClass: AnyConstructorFunction;
+    private readonly _implementationNames;
+    private readonly _implementations?;
+    private _allImplementations?;
+    constructor(def: RawClassDefinition & {
+        jsClass: AnyConstructorFunction;
+    });
+    get allMethods(): Dictionary<MethodDefinition>;
+    get allProperties(): Dictionary<PropertyDefinition>;
+    get implementations(): ImplementationOfClass[];
+    get allImplementations(): ImplementationOfClass[];
+    getProperty(propName: string): PropertyDefinition | undefined;
+    get type(): TypeDefinition;
+    isSubClassOf(typeName: string): boolean;
+    isSuperClassOf(typeName: string): boolean;
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import type { RawEnumDefinition, TypeDefinition } from './reflect-definitions';
+export declare class EnumDefinition {
+    readonly name: string;
+    readonly members: Map<string, TypeDefinition>;
+    constructor(def: RawEnumDefinition);
+    get type(): TypeDefinition;
+    get names(): string[];
+}

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

@@ -0,0 +1,18 @@
+import { ClassDefinition, RawInterfaceDefinition, TypeDefinition } from './index';
+import { MethodDefinition, PropertyDefinition } from './index';
+type ImplementationOfInterface = InterfaceDefinition | ClassDefinition | TypeDefinition;
+export declare class InterfaceDefinition {
+    readonly name: string;
+    readonly methods: MethodDefinition[];
+    readonly properties: PropertyDefinition[];
+    private readonly _implementationNames;
+    private _implementations?;
+    private _allImplementations?;
+    constructor(def: RawInterfaceDefinition);
+    get implementations(): ImplementationOfInterface[];
+    get allImplementations(): ImplementationOfInterface[];
+    get type(): TypeDefinition;
+    toString(): string;
+    buildBaseObject(): {};
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { type RawMethodDefinition, type TypeDefinition } from './index';
+export declare class MethodDefinition {
+    name: string;
+    isPrivate: boolean;
+    isStatic: boolean;
+    isAsync: boolean;
+    returnType: TypeDefinition;
+    args: {
+        name: string;
+        type?: TypeDefinition;
+        isOptional: boolean;
+    }[];
+    constructor(def: RawMethodDefinition);
+}
+export declare function fillMethod(rawMethod: RawMethodDefinition): MethodDefinition;

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

@@ -0,0 +1,18 @@
+import { type RawPropertyDefinition, type TypeDefinition } from './index';
+export declare class PropertyDefinition {
+    name: string;
+    isOptional: boolean;
+    isPrivate: boolean;
+    isStatic: boolean;
+    type: TypeDefinition;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+    constructor(def: RawPropertyDefinition);
+}
+export declare function fillProperty(rawProperty: RawPropertyDefinition): PropertyDefinition;

package/types/reflect-types/assert-type.d.ts

@@ -0,0 +1,14 @@
+import { type TypeDefinition } from '.';
+export type Type = string | {
+    array: Type;
+} | {
+    union: Type[];
+} | {
+    intersection: Type[];
+} | {
+    tuple: 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): boolean;

package/types/reflect-types/function-validate.d.ts

@@ -0,0 +1,10 @@
+import { type AnyFunction } from './package';
+declare const VALIDATE_WRAPPER: unique symbol;
+declare global {
+    interface Function {
+        [VALIDATE_WRAPPER]: AnyFunction;
+    }
+}
+export declare const ReflectValidate: MethodDecorator;
+export declare function safeCall(target: object, methodName: string, ...args: unknown[]): unknown;
+export {};

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

@@ -0,0 +1,11 @@
+export * from './reflect-definitions';
+export * from './reflect-context';
+export * from './ClassDefinition';
+export * from './InterfaceDefinition';
+export * from './EnumDefinition';
+export * from './MethodDefinition';
+export * from './PropertyDefinition';
+export * from './reflect-types';
+export * from './reflect-validate';
+export * from './assert-type';
+export * from './function-validate';

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

@@ -0,0 +1,10 @@
+export type Dictionary<T> = {
+    [key: string]: T;
+};
+type Any = any;
+export type AnyConstructorFunction = new (...args: Any[]) => Any;
+export type AnyFunction = (...args: Any[]) => Any;
+export declare function setValue<T>(target: unknown, field: string | symbol, value: T): void;
+export declare function getValue<T>(target: unknown, field: string | symbol): T | undefined;
+export declare function mapNotNull<T, U>(arr: T[] | undefined, mapper: (item: T) => U | undefined): U[];
+export {};

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

@@ -0,0 +1,16 @@
+import type { AnyConstructorFunction } from './package';
+import { type TypeDefinition } from './index';
+import { ClassDefinition, EnumDefinition, InterfaceDefinition } from './index';
+export declare const ReflectClass: ClassDecorator;
+export declare const ReflectContext: {
+    getClassDefinition: typeof getClassDefinition;
+    getInterfaceDefinition: typeof getInterfaceDefinition;
+    getEnumDefinition: typeof getEnumDefinition;
+    getTypeAliasDefinition: typeof getTypeAliasDefinition;
+};
+export declare function getClassByName(className: string): AnyConstructorFunction | undefined;
+declare function getClassDefinition(arg: AnyConstructorFunction | object | string): ClassDefinition | undefined;
+declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
+export {};

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

@@ -0,0 +1,104 @@
+import { ClassDefinition, PropertyDefinition } from './index';
+export interface RawTypeDefinition {
+    arrayElementType?: RawTypeDef;
+    literalValue?: unknown;
+    typeLiteralMembers?: RawPropertyDefinition[];
+    unionMembers?: RawTypeDef[];
+    intersectionMembers?: RawTypeDef[];
+    isFunction?: boolean;
+    tupleMembers?: RawTypeDef[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: RawTypeDef[];
+}
+type RawTypeDef = string | RawTypeDefinition;
+export interface RawClassDefinition {
+    name: string;
+    superClassName?: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawInterfaceDefinition {
+    name: string;
+    implementations?: string[];
+    methods?: RawMethodDefinition[];
+    properties?: RawPropertyDefinition[];
+}
+export interface RawEnumDefinition {
+    name: string;
+    members: {
+        name: string;
+        initializer: string | undefined;
+    }[];
+}
+export interface RawMethodDefinition {
+    name: string;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    returnType?: RawTypeDef;
+    args?: {
+        name: string;
+        type?: RawTypeDef;
+        isOptional: boolean;
+    }[];
+}
+export interface RawPropertyDefinition {
+    name: string;
+    isOptional?: boolean;
+    isPrivate?: boolean;
+    isStatic?: boolean;
+    type?: RawTypeDef;
+    accessor?: {
+        getter?: {
+            isPrivate: boolean;
+        };
+        setter?: {
+            isPrivate: boolean;
+        };
+    };
+}
+export interface TypeDefinition {
+    name?: string;
+    arrayElementType?: TypeDefinition;
+    literalValue?: string;
+    typeLiteralMembers?: PropertyDefinition[];
+    unionMembers?: TypeDefinition[];
+    intersectionMembers?: TypeDefinition[];
+    isFunction?: boolean;
+    tupleMembers?: TypeDefinition[];
+    isOptionalInTuple?: boolean;
+    isConstructor?: boolean;
+    generics?: TypeDefinition[];
+    classDefinition?: ClassDefinition;
+}
+export declare function isIgnoredType(type: TypeDefinition): boolean;
+export declare function isPrimitiveType(type: TypeDefinition): type is {
+    name: string;
+};
+export declare function isArrayType(type: TypeDefinition): type is {
+    arrayElementType: TypeDefinition;
+};
+export declare function isLiteralType(type: TypeDefinition): type is {
+    literalValue: string;
+};
+export declare function isTypeLiteralType(type: TypeDefinition): type is {
+    typeLiteralMembers: PropertyDefinition[];
+};
+export declare function isUnionType(type: TypeDefinition): type is {
+    unionMembers: TypeDefinition[];
+};
+export declare function isIntersectionType(type: TypeDefinition): type is {
+    intersectionMembers: TypeDefinition[];
+};
+export declare function isTupleType(type: TypeDefinition): type is {
+    tupleMembers: TypeDefinition[];
+};
+export declare function isClassDefinition(type: TypeDefinition): type is {
+    classDefinition: ClassDefinition;
+};
+export declare function hasGenerics(type: TypeDefinition): type is {
+    generics: TypeDefinition[];
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { type RawTypeDefinition, type TypeDefinition } from './index';
+import { ClassDefinition, EnumDefinition, InterfaceDefinition } from './index';
+import { type AnyConstructorFunction } from './package';
+export declare const anyType: {
+    name: string;
+};
+export declare const nullType: {
+    name: string;
+};
+export declare function getClassDefinition(arg: AnyConstructorFunction | object | string): ClassDefinition | undefined;
+export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
+export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
+export declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
+export declare function getTypeDefinition(typeName: string): TypeDefinition;
+export declare function getEnumNames(enumName: string): string[];
+export declare function getEnumValues(args: {
+    [enumName: string]: Record<string, string | number>;
+}): (string | number)[];
+export declare function fillType(rawType: RawTypeDefinition | string | undefined): TypeDefinition;
+export type EnableReflect = object;

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

@@ -0,0 +1,24 @@
+import { type TypeDefinition } from './index';
+import { type Dictionary } from './package';
+interface ValidateResult {
+    success: boolean;
+    errorMessage?: string;
+}
+export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
+export declare function validateInstance<T extends object>(instance: T, typeName?: string, depth?: number): ValidateResult;
+export declare function validateArray<T extends object>(array: T[], typeName?: string, depth?: number): ValidateResult;
+export declare function validateDictionary<T extends object>(dict: Dictionary<T>, typeName?: string, depth?: number): ValidateResult;
+interface FailureResult extends ValidateResult {
+    cause?: FailureResult;
+}
+export declare function getErrorTraceMessages(failureResult: FailureResult): string;
+export declare function validateFunctionArgument(args: {
+    funcName: string;
+    optionsObj?: object;
+    value?: unknown;
+    argName: string;
+    type: string;
+    optional?: boolean;
+}): void;
+export declare function safeSetValue(target: object, propName: string, value: unknown): void;
+export {};

package/dist/types/index.d.ts

@@ -1,455 +0,0 @@
-export declare const AfterSerialized: PropertyDecorator;
-
-export declare type Any = any;
-
-declare type Any_2 = any;
-
-export declare type AnyConstructorFunction = new (...args: Any[]) => Any;
-
-declare type AnyConstructorFunction_2 = new (...args: Any_2[]) => Any_2;
-
-export declare type AnyFunction = (...args: Any[]) => Any;
-
-export declare type AnyObject = Dictionary<Any>;
-
-export declare const anyType: {
-    name: string;
-};
-
-export declare function asBoolean(value: unknown): boolean;
-
-export declare function asNumber(v: unknown): number;
-
-export declare function assertType<T>(data: unknown, type: Type, depth?: number): T;
-
-export declare function asString(v: unknown): string;
-
-export declare function callDecoratedMethod<Self extends object>(self: Self, metaKey: symbol, ...args: Any[]): Any | undefined;
-
-export declare type Class<T> = new (...args: Any[]) => T;
-
-export declare class ClassDefinition {
-    readonly name: string;
-    readonly superClassName: string;
-    readonly superClass: ClassDefinition | undefined;
-    readonly methods: MethodDefinition[];
-    readonly properties: PropertyDefinition_2[];
-    readonly jsClass: AnyConstructorFunction_2;
-    private readonly _implementationNames;
-    private readonly _implementations?;
-    private _allImplementations?;
-    constructor(def: RawClassDefinition & {
-        jsClass: AnyConstructorFunction_2;
-    });
-    get allMethods(): Dictionary_2<MethodDefinition>;
-    get allProperties(): Dictionary_2<PropertyDefinition_2>;
-    get implementations(): ImplementationOfClass[];
-    get allImplementations(): ImplementationOfClass[];
-    getProperty(propName: string): PropertyDefinition_2 | undefined;
-    get type(): TypeDefinition;
-    isSubClassOf(typeName: string): boolean;
-    isSuperClassOf(typeName: string): boolean;
-    toString(): string;
-}
-
-export declare type ClassOrInstance<T> = T | Class<T>;
-
-export declare function createNewInstance<T>(clazz: Class<T>): any;
-
-export declare function defineDecoratedProperty(metaKey: symbol): PropertyDecorator;
-
-export declare function deserialize<T>(json: string | JsonValue, constructorOrTarget?: ClassOrInstance<T>): T;
-
-export declare function deserializeArray<T>(json: string | JsonValue[], clazz?: Class<T>): T[];
-
-export declare function deserializeFrom<T extends AnyObject>(data: JsonObject, target: T): void;
-
-export declare type Dictionary<T> = {
-    [key: string | symbol]: T;
-};
-
-declare type Dictionary_2<T> = {
-    [key: string]: T;
-};
-
-export declare const done: () => any;
-
-export declare type EnableReflect = object;
-
-export declare class EnumDefinition {
-    readonly name: string;
-    readonly members: Map<string, TypeDefinition>;
-    constructor(def: RawEnumDefinition);
-    get type(): TypeDefinition;
-    get names(): string[];
-}
-
-declare interface FailureResult extends ValidateResult {
-    cause?: FailureResult;
-}
-
-export declare function fillMethod(rawMethod: RawMethodDefinition): MethodDefinition;
-
-export declare function fillProperty(rawProperty: RawPropertyDefinition): PropertyDefinition_2;
-
-export declare function fillType(rawType: RawTypeDefinition | string | undefined): TypeDefinition;
-
-declare type FromJSON<T> = (jsonValue: JsonValue) => T;
-
-export declare function getAnyValue<T>(target: Any, field: string | number | symbol): T | undefined;
-
-export declare function getClassByName(className: string): AnyConstructorFunction_2 | undefined;
-
-export declare function getClassDefinition(arg: AnyConstructorFunction_2 | object | string): ClassDefinition | undefined;
-
-declare function getClassDefinition_2(arg: AnyConstructorFunction_2 | object | string): ClassDefinition | undefined;
-
-export declare function getDecoratedProperty(target: object, metaKey: symbol): ReflectPropertyKey | undefined;
-
-export declare function getDecoratedPropertyValue<V>(target: object, metaKey: symbol): V | undefined;
-
-export declare function getEnumDefinition(name: string): EnumDefinition | undefined;
-
-declare function getEnumDefinition_2(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 getErrorTraceMessages(failureResult: FailureResult): string;
-
-export declare function getInterfaceDefinition(name: string): InterfaceDefinition | undefined;
-
-declare function getInterfaceDefinition_2(name: string): InterfaceDefinition | undefined;
-
-export declare function getOrSetValue<T>(target: Any, field: string | number | symbol, defaultWith: () => T): T;
-
-export declare function getSerializeSettings(clazz: Class<Any>): any;
-
-export declare function getTypeAliasDefinition(name: string): TypeDefinition | undefined;
-
-declare function getTypeAliasDefinition_2(name: string): TypeDefinition | undefined;
-
-export declare function getTypeDef(type: Type | TypeDefinition): TypeDefinition;
-
-export declare function getTypeDefinition(typeName: string): TypeDefinition;
-
-export declare function hasDecoratedMethod<Self extends object>(self: Self, metaKey: symbol): boolean;
-
-export declare function hasGenerics(type: TypeDefinition): type is {
-    generics: TypeDefinition[];
-};
-
-export declare const IgnoreSerialization: PropertyDecorator;
-
-declare type ImplementationOfClass = InterfaceDefinition | TypeDefinition;
-
-declare type ImplementationOfInterface = InterfaceDefinition | ClassDefinition | TypeDefinition;
-
-export declare class InterfaceDefinition {
-    readonly name: string;
-    readonly methods: MethodDefinition[];
-    readonly properties: PropertyDefinition_2[];
-    private readonly _implementationNames;
-    private _implementations?;
-    private _allImplementations?;
-    constructor(def: RawInterfaceDefinition);
-    get implementations(): ImplementationOfInterface[];
-    get allImplementations(): ImplementationOfInterface[];
-    get type(): TypeDefinition;
-    toString(): string;
-    buildBaseObject(): {};
-}
-
-declare type IPropertyWrapper = {
-    getField: (owner: object, property: ReflectPropertyKey, fieldSymbol: symbol) => Any;
-    setField: (owner: object, property: ReflectPropertyKey, newValue: Any, fieldSymbol: symbol) => void;
-} & (<T>({ getter, setter, fieldSymbol }: {
-    getter?: (self: object, property: ReflectPropertyKey) => T;
-    setter?: (self: object, newValue: T, property: ReflectPropertyKey) => void;
-    fieldSymbol: symbol;
-}) => PropertyDecorator);
-
-export declare function isArrayType(type: TypeDefinition): type is {
-    arrayElementType: TypeDefinition;
-};
-
-export declare function isClassDefinition(type: TypeDefinition): type is {
-    classDefinition: ClassDefinition;
-};
-
-export declare function isDictionary(value: Any): boolean;
-
-export declare function isIgnoredType(type: TypeDefinition): boolean;
-
-export declare function isIntersectionType(type: TypeDefinition): type is {
-    intersectionMembers: TypeDefinition[];
-};
-
-export declare function isLiteralType(type: TypeDefinition): type is {
-    literalValue: string;
-};
-
-export declare function isNullable(type: Type | TypeDefinition): boolean;
-
-export declare function isPrimitiveType(type: TypeDefinition): type is {
-    name: string;
-};
-
-export declare function isTupleType(type: TypeDefinition): type is {
-    tupleMembers: TypeDefinition[];
-};
-
-export declare function isType(value: unknown, type: Type | TypeDefinition): boolean;
-
-export declare function isTypeLiteralType(type: TypeDefinition): type is {
-    typeLiteralMembers: PropertyDefinition_2[];
-};
-
-export declare function isUnionType(type: TypeDefinition): type is {
-    unionMembers: TypeDefinition[];
-};
-
-export declare const itSelf: (some: Any) => any;
-
-export declare type JsonObject = {
-    [propName: string]: JsonValue;
-};
-
-export declare type JsonValue = string | number | boolean | null | JsonObject | JsonObject[];
-
-export declare interface JsonValueTransform<T> {
-    fromJson: FromJSON<T>;
-    toJson: ToJSON<T>;
-}
-
-export declare function Lazy(creator: (self: object, property: ReflectPropertyKey) => Any): PropertyDecorator;
-
-export declare function mapAllProperties<T extends Mappable>(target: T, map: Mapping<T>): void;
-
-export declare interface Mappable extends EnableReflect {
-    mapping(map: Mapping<Mappable>): void;
-}
-
-export declare type Mapping<T extends Mappable> = {
-    [propName in keyof T]-?: (fieldName?: string | symbol, transform?: {
-        fromJSON?: (jsonValue: JsonValue) => Mappable;
-        toJSON?: (obj: Mappable) => JsonValue;
-    }) => void;
-};
-
-export declare class MethodDefinition {
-    name: string;
-    isPrivate: boolean;
-    isStatic: boolean;
-    isAsync: boolean;
-    returnType: TypeDefinition;
-    args: {
-        name: string;
-        type?: TypeDefinition;
-        isOptional: boolean;
-    }[];
-    constructor(def: RawMethodDefinition);
-}
-
-export declare type Nullable<T> = T | null;
-
-export declare const nullType: {
-    name: string;
-};
-
-export declare type Optional<T> = T | undefined;
-
-declare class PropertyDefinition_2 {
-    name: string;
-    isOptional: boolean;
-    isPrivate: boolean;
-    isStatic: boolean;
-    type: TypeDefinition;
-    accessor?: {
-        getter?: {
-            isPrivate: boolean;
-        };
-        setter?: {
-            isPrivate: boolean;
-        };
-    };
-    constructor(def: RawPropertyDefinition);
-}
-export { PropertyDefinition_2 as PropertyDefinition }
-
-export declare const PropertyWrapper: IPropertyWrapper;
-
-export declare interface RawClassDefinition {
-    name: string;
-    superClassName?: string;
-    implementations?: string[];
-    methods?: RawMethodDefinition[];
-    properties?: RawPropertyDefinition[];
-}
-
-export declare interface RawEnumDefinition {
-    name: string;
-    members: {
-        name: string;
-        initializer: string | undefined;
-    }[];
-}
-
-export declare interface RawInterfaceDefinition {
-    name: string;
-    implementations?: string[];
-    methods?: RawMethodDefinition[];
-    properties?: RawPropertyDefinition[];
-}
-
-export declare interface RawMethodDefinition {
-    name: string;
-    isPrivate?: boolean;
-    isStatic?: boolean;
-    isAsync?: boolean;
-    returnType?: RawTypeDef;
-    args?: {
-        name: string;
-        type?: RawTypeDef;
-        isOptional: boolean;
-    }[];
-}
-
-export declare interface RawPropertyDefinition {
-    name: string;
-    isOptional?: boolean;
-    isPrivate?: boolean;
-    isStatic?: boolean;
-    type?: RawTypeDef;
-    accessor?: {
-        getter?: {
-            isPrivate: boolean;
-        };
-        setter?: {
-            isPrivate: boolean;
-        };
-    };
-}
-
-declare type RawTypeDef = string | RawTypeDefinition;
-
-export declare interface RawTypeDefinition {
-    arrayElementType?: RawTypeDef;
-    literalValue?: unknown;
-    typeLiteralMembers?: RawPropertyDefinition[];
-    unionMembers?: RawTypeDef[];
-    intersectionMembers?: RawTypeDef[];
-    isFunction?: boolean;
-    tupleMembers?: RawTypeDef[];
-    isOptionalInTuple?: boolean;
-    isConstructor?: boolean;
-    generics?: RawTypeDef[];
-}
-
-export declare const ReflectClass: ClassDecorator;
-
-export declare const ReflectContext: {
-    getClassDefinition: typeof getClassDefinition_2;
-    getInterfaceDefinition: typeof getInterfaceDefinition_2;
-    getEnumDefinition: typeof getEnumDefinition_2;
-    getTypeAliasDefinition: typeof getTypeAliasDefinition_2;
-};
-
-export declare type ReflectPropertyKey = string | symbol;
-
-export declare type ReflectType = StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | FunctionConstructor | AnyConstructorFunction;
-
-export declare const ReflectValidate: MethodDecorator;
-
-export declare function registerMappable<T extends Mappable>(mappableClass: Class<T>): void;
-
-export declare function registerSerializedProperty(target: AnyObject, propName: string, options: SerializedOptions<Any>): void;
-
-export declare function registerTransform<T>(clazz: Class<T>, transform: JsonValueTransform<T>): void;
-
-export declare function safeCall(target: object, methodName: string, ...args: unknown[]): unknown;
-
-export declare function safeSetValue(target: object, propName: string, value: unknown): void;
-
-/**
- * serialize an object to json string
- */
-export declare function serialize<T>(value: T): string;
-
-export declare function Serialized<T extends object>(options?: SerializedOptions<T>): PropertyDecorator;
-
-export declare const SerializedClass: PropertyDecorator;
-
-export declare function SerializedName(serializedName: string): PropertyDecorator;
-
-declare type SerializedOptions<T> = {
-    name?: string;
-    class?: Class<T>;
-    fromJSON?: FromJSON<T>;
-    toJSON?: ToJSON<T>;
-};
-
-export declare function serializeTo<T>(value: T): JsonValue;
-
-/**
- * convert an object to data object
- */
-export declare function serializeToData<T extends object>(object: T): JsonObject | JsonObject[];
-
-export declare function setAnyValue<T>(target: Any, field: string | number | symbol, value: T): void;
-
-export declare function setDefaultIgnored(clazz: Class<Any>, defaultIgnored: boolean): void;
-
-declare type ToJSON<T> = (obj: T) => JsonValue;
-
-export declare type Type = string | {
-    array: Type;
-} | {
-    union: Type[];
-} | {
-    intersection: Type[];
-} | {
-    tuple: Type[];
-};
-
-export declare interface TypeDefinition {
-    name?: string;
-    arrayElementType?: TypeDefinition;
-    literalValue?: string;
-    typeLiteralMembers?: PropertyDefinition_2[];
-    unionMembers?: TypeDefinition[];
-    intersectionMembers?: TypeDefinition[];
-    isFunction?: boolean;
-    tupleMembers?: TypeDefinition[];
-    isOptionalInTuple?: boolean;
-    isConstructor?: boolean;
-    generics?: TypeDefinition[];
-    classDefinition?: ClassDefinition;
-}
-
-export declare function validateArray<T extends object>(array: T[], typeName?: string, depth?: number): ValidateResult;
-
-export declare function validateDictionary<T extends object>(dict: Dictionary_2<T>, typeName?: string, depth?: number): ValidateResult;
-
-export declare function validateFunctionArgument(args: {
-    funcName: string;
-    optionsObj?: object;
-    value?: unknown;
-    argName: string;
-    type: string;
-    optional?: boolean;
-}): void;
-
-export declare function validateInstance<T extends object>(instance: T, typeName?: string, depth?: number): ValidateResult;
-
-declare interface ValidateResult {
-    success: boolean;
-    errorMessage?: string;
-}
-
-export declare function validateValue(value: unknown, type: TypeDefinition, depth?: number): ValidateResult;
-
-export { }

package/dist/types/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.52.11"
-    }
-  ]
-}