@tsed/core 7.79.4 → 7.80.0

package/lib/cjs/utils/imports/importPackage.js

@@ -1,30 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importPackage = void 0;
-async function importPackage(packageName, loaderFn = () => { var _a; return _a = packageName, Promise.resolve().then(() => __importStar(require(_a))); }, optional = false) {
+async function importPackage(packageName, loaderFn = () => import(packageName), optional = false) {
     try {
         return await loaderFn();
     }

package/lib/cjs/utils/imports/importPackage.js.map

@@ -1 +1 @@
-{"version":3,"file":"importPackage.js","sourceRoot":"","sources":["../../../../src/utils/imports/importPackage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,KAAK,UAAU,aAAa,CAAC,WAAmB,EAAE,WAAqB,GAAG,EAAE,uBAAQ,WAAW,4DAAC,EAAE,QAAQ,GAAG,KAAK;IACvH,IAAI;QACF,OAAO,MAAM,QAAQ,EAAE,CAAC;KACzB;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,CAAC,CAAC;SACT;QAED,OAAO,EAAE,CAAC;KACX;AACH,CAAC;AAVD,sCAUC"}
+{"version":3,"file":"importPackage.js","sourceRoot":"","sources":["../../../../src/utils/imports/importPackage.ts"],"names":[],"mappings":";;;AAAO,KAAK,UAAU,aAAa,CAAC,WAAmB,EAAE,WAAqB,GAAG,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,KAAK;IACvH,IAAI;QACF,OAAO,MAAM,QAAQ,EAAE,CAAC;KACzB;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,QAAQ,EAAE;YACb,MAAM,CAAC,CAAC;SACT;QAED,OAAO,EAAE,CAAC;KACX;AACH,CAAC;AAVD,sCAUC"}

package/lib/types-esm/decorators/configurable.d.ts

@@ -0,0 +1 @@
+export declare function Configurable(value?: boolean): Function;

package/lib/types-esm/decorators/deprecated.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The `@Deprecated()` decorators wraps the given method in such a way that it is marked as deprecated.
+ *
+ * ```typescript
+ * provide Foo {
+ *
+ * @Deprecated("Foo.method: Use Foo.method2 instead")
+ * public method() {
+ *
+ * }
+ * ```
+ *
+ * When called, @Deprecated() will return a function that will emit a `DeprecationWarning` using the `process.on('warning')` event.
+ * By default, this warning will be emitted and printed to `stderr` exactly once, the first time it is called. After the warning is emitted, the wrapped method is called.
+ *
+ * If either the `--no-deprecation` or `--no-warnings` command line flags are used, or if the `process.noDeprecation`
+ * property is set to `true` prior to the first deprecation warning, the `@Deprecated()` decorators does nothing.
+ *
+ * If the `--trace-deprecation` or `--trace-warnings` command line flags are set, or the `process.traceDeprecation`
+ * property is set to `true`, a warning and a stack trace are printed to stderr the first time the deprecated function is called.
+ *
+ * If the `--throw-deprecation` command line flag is set, or the `process.throwDeprecation` property is set to `true`,
+ * then an exception will be thrown when the deprecated function is called.
+ *
+ * The `--throw-deprecation` command line flag and `process.throwDeprecation` property take precedence over `--trace-deprecation`
+ * and `process.traceDeprecation`.
+ *
+ * @param message
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Deprecated(message: string): Function;

package/lib/types-esm/decorators/enumerable.d.ts

@@ -0,0 +1 @@
+export declare function Enumerable(value?: boolean): Function;

package/lib/types-esm/decorators/notConfigurable.d.ts

@@ -0,0 +1 @@
+export declare function NotConfigurable(): Function;

package/lib/types-esm/decorators/notEnumerable.d.ts

@@ -0,0 +1 @@
+export declare function NotEnumerable(): Function;

package/lib/types-esm/decorators/readOnly.d.ts

@@ -0,0 +1 @@
+export declare function Readonly(): Function;

package/lib/types-esm/decorators/storeFn.d.ts

@@ -0,0 +1,9 @@
+import { Store } from "../domain/Store.js";
+import { DecoratorParameters } from "../interfaces/DecoratorParameters.js";
+/**
+ * Create a store correctly configured from the parameters given by the decorator.
+ * The `fn` can return a decorator that will be initialized with the parameters (target, propertyKey, descriptor).
+ * @param {(store: Store, parameters: DecoratorParameters) => void} fn
+ * @returns {Function}
+ */
+export declare function StoreFn(fn: (store: Store, parameters: DecoratorParameters) => void): Function;

package/lib/types-esm/decorators/storeMerge.d.ts

@@ -0,0 +1 @@
+export declare function StoreMerge(key: any, value: any): Function;

package/lib/types-esm/decorators/storeSet.d.ts

@@ -0,0 +1 @@
+export declare function StoreSet(key: any, value: any): Function;

package/lib/types-esm/decorators/writable.d.ts

@@ -0,0 +1 @@
+export declare function Writable(value?: boolean): Function;

package/lib/types-esm/domain/AnyToPromise.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @ignore
+ */
+export declare enum AnyToPromiseStatus {
+    PENDING = "PENDING",
+    CANCELED = "CANCELED",
+    RESOLVED = "RESOLVED",
+    REJECTED = "REJECTED"
+}
+export declare enum AnyToPromiseResponseTypes {
+    STREAM = "STREAM",
+    BUFFER = "BUFFER",
+    DATA = "DATA"
+}
+export interface AnyPromiseResult<T = any> {
+    state: AnyToPromiseStatus;
+    type: AnyToPromiseResponseTypes;
+    status?: number;
+    headers?: Record<string, any>;
+    data: T;
+}
+export declare class AnyToPromise<T = any> {
+    #private;
+    status: AnyToPromiseStatus;
+    args: any[];
+    constructor({ hasNextFunction }?: {
+        hasNextFunction?: boolean;
+    });
+    isDone(): boolean;
+    get next(): (error?: any) => void;
+    /**
+     *
+     */
+    call(cb: Function): Promise<AnyPromiseResult<T>>;
+    reject(er: any): void;
+    resolve(response?: any): void;
+    destroy(): void;
+    cancel(): any;
+    done(status: AnyToPromiseStatus): void;
+    handle(process: any, additionalProps?: {}): any;
+    protected isCanceledResponse(process: any): boolean;
+}

package/lib/types-esm/domain/DecoratorTypes.d.ts

@@ -0,0 +1,10 @@
+export declare enum DecoratorTypes {
+    PARAM = "parameter",
+    PARAM_CTOR = "parameter.constructor",
+    PARAM_STC = "parameter.static",
+    PROP = "property",
+    PROP_STC = "property.static",
+    METHOD = "method",
+    METHOD_STC = "method.static",
+    CLASS = "class"
+}

package/lib/types-esm/domain/Env.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare enum Env {
+    PROD = "production",
+    DEV = "development",
+    TEST = "test"
+}
+/**
+ * Fallback
+ * @type {Env}
+ */
+export declare const EnvTypes: typeof Env;

package/lib/types-esm/domain/Hooks.d.ts

@@ -0,0 +1,47 @@
+export declare class Hooks {
+    #private;
+    has(event: string): boolean;
+    /**
+     * Listen a hook event
+     * @param event
+     * @param cb
+     */
+    on(event: string, cb: Function): this;
+    /**
+     * Remove a listener attached to an event
+     * @param event
+     * @param cb
+     */
+    off(event: string, cb: Function): this;
+    /**
+     * Trigger an event and call listener.
+     * @param event
+     * @param args
+     * @param callThis
+     */
+    emit(event: string, args?: any[], callThis?: any): void;
+    /**
+     * Trigger an event, listener alter given value and return it.
+     * @param event
+     * @param value
+     * @param args
+     * @param callThis
+     */
+    alter<Arg = any, AlteredArg = Arg>(event: string, value: Arg, args?: any[], callThis?: any): AlteredArg;
+    /**
+     * Trigger an event and call async listener.
+     * @param event
+     * @param args
+     * @param callThis
+     */
+    asyncEmit(event: string, args?: any[], callThis?: any): Promise<void>;
+    /**
+     * Trigger an event, async listener alter given value and return it.
+     * @param event
+     * @param value
+     * @param args
+     * @param callThis
+     */
+    asyncAlter<Arg = any, AlteredArg = Arg>(event: string, value: Arg, args?: any[], callThis?: any): Promise<AlteredArg>;
+    destroy(): void;
+}

package/lib/types-esm/domain/Metadata.d.ts

@@ -0,0 +1,442 @@
+import "reflect-metadata";
+/**
+ * @stable
+ */
+export declare class Metadata {
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.get("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.get("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.get("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.get("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.get("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static get(key: string, target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.getOwn("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwn("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.getOwn("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwn("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.getOwn("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static getOwn(key: string, target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getOwnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getReturnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getReturnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getReturnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getReturnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_RETURN_TYPE on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getOwnReturnType(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getOwnReturnType(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getOwnReturnType(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnReturnType(target: any, propertyKey?: string | symbol): any;
+    /**
+     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.has("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.has("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.has("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.has("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.has("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static has(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.has("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.hasOwn("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.hasOwn("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.hasOwn("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static hasOwn(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Deletes the metadata entry from the target object with the provided key.
+     * @param key A key used to store and retrieve metadata.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns `true` if the metadata entry was found and deleted; otherwise, false.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * result = Metadata.delete("custom:annotation", Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.delete("custom:annotation", Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * result = Metadata.delete("custom:annotation", Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * result = Metadata.delete("custom:annotation", Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * result = Metadata.delete("custom:annotation", Example.prototype, "method");
+     * ```
+     *
+     */
+    static delete(key: string, target: any, propertyKey?: string | symbol): boolean;
+    /**
+     * Set the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @param value A value that contains attached metadata.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.setParamTypes(Example, undefined, [Object]);
+     *
+     * // property (on constructor)
+     * result = Metadata.setParamTypes(Example, "staticProperty", [Object]);
+     *
+     * // property (on prototype)
+     * result = Metadata.setParamTypes(Example.prototype, "property", [Object]);
+     *
+     * // method (on constructor)
+     * result = Metadata.setParamTypes(Example, "staticMethod", [Object]);
+     *
+     * // method (on prototype)
+     * result = Metadata.setParamTypes(Example.prototype, "method", [Object]);
+     * ```
+     *
+     */
+    static setParamTypes(target: any, propertyKey: string | symbol, value: any): void;
+    /**
+     * Get all metadata for a metadataKey.
+     * @param metadataKey
+     */
+    static getTargetsFromPropertyKey: (metadataKey: string | symbol) => any[];
+    /**
+     * Define a unique metadata entry on the target.
+     * @param key A key used to store and retrieve metadata.
+     * @param value A value that contains attached metadata.
+     * @param target The target object on which to define metadata.
+     * @param propertyKey The property key for the target.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // constructor
+     * Reflect.defineMetadata("custom:annotation", options, Example);
+     *
+     * // property (on constructor)
+     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
+     *
+     * // property (on prototype)
+     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
+     *
+     * // method (on constructor)
+     * Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
+     *
+     * // method (on prototype)
+     * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
+     *
+     * // decorator factory as metadata-producing annotation.
+     * function MyAnnotation(options): PropertyDecorator {
+     *     return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
+     * }
+     * ```
+     *
+     */
+    static set(key: string, value: any, target: any, propertyKey?: string | symbol): void;
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param targetPrototype
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getParamTypes(Example.prototype);
+     *
+     * // property (on constructor)
+     * result = Metadata.getParamTypes(Example.prototype, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getParamTypes(Example.prototype, "staticMethod");
+     * ```
+     *
+     */
+    static getParamTypes(targetPrototype: any, propertyKey?: string | symbol): any[];
+    /**
+     * Gets the metadata value for the provided metadata DESIGN_PARAM_TYPES on the target object or its prototype chain.
+     * @param target The target object on which the metadata is defined.
+     * @param propertyKey The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
+     * @example
+     *
+     * ```typescript
+     * class Example {
+     *     // property declarations are not part of ES6, though they are valid in TypeScript:
+     *     // static staticProperty;
+     *     // property;
+     *
+     *     static staticMethod(p) { }
+     *     method(p) { }
+     * }
+     *
+     * // on contructor
+     * result = Metadata.getParamTypes(Example);
+     *
+     * // property (on constructor)
+     * result = Metadata.getParamTypes(Example, "staticProperty");
+     *
+     * // method (on constructor)
+     * result = Metadata.getParamTypes(Example, "staticMethod");
+     * ```
+     *
+     */
+    static getOwnParamTypes(target: any, propertyKey?: string | symbol): any[];
+}