@tstdl/base 0.90.59 → 0.90.61

package/.eslintrc.json

@@ -33,7 +33,7 @@
     "eqeqeq": ["off"],
     "explicit-function-return-type": ["off"],
     "explicit-member-accessibility": ["off"],
-    "func-style": ["error", "declaration", { "allowArrowFunctions": true }],
+    "func-style": ["warn", "declaration", { "allowArrowFunctions": true }],
     "id-length": ["off"],
     "init-declarations": ["off"],
     "line-comment-position": ["off"],
@@ -47,7 +47,7 @@
     "no-bitwise": ["off"],
     "no-case-declarations": ["warn"],
     "no-confusing-void-expression": ["off"],
-    "no-constant-condition": ["error", { "checkLoops": false }],
+    "no-constant-condition": ["warn", { "checkLoops": false }],
     "no-continue": ["off"],
     "no-duplicate-imports": ["off"],
     "no-empty-interface": ["off"],
@@ -67,7 +67,7 @@
     "no-unused-vars": ["off"],
     "no-use-before-define": ["off"],
     "no-void": ["warn", { "allowAsStatement": true }],
-    "one-var": ["error", "never"],
+    "one-var": ["warn", "never"],
     "prefer-arrow-callback": ["warn"],
     "prefer-destructuring": ["off"],
     "prefer-named-capture-group": ["warn"],
@@ -76,27 +76,27 @@
     "sort-keys": ["off"],
     "sort-type-constituents": ["off"],
 
-    "@typescript-eslint/ban-types": ["error"],
+    "@typescript-eslint/ban-types": ["warn"],
     "@typescript-eslint/class-methods-use-this": ["warn", { "ignoreOverrideMethods": true, "ignoreClassesThatImplementAnInterface": true }],
     "@typescript-eslint/consistent-type-definitions": ["off"],
     "@typescript-eslint/consistent-type-imports": ["warn", { "prefer": "type-imports", "fixStyle": "inline-type-imports", "disallowTypeAnnotations": false }],
-    "@typescript-eslint/explicit-function-return-type": ["error", { "allowExpressions": true, "allowFunctionsWithoutTypeParameters": true }],
-    "@typescript-eslint/explicit-member-accessibility": ["error", { "accessibility": "no-public" }],
+    "@typescript-eslint/explicit-function-return-type": ["warn", { "allowExpressions": true, "allowFunctionsWithoutTypeParameters": true }],
+    "@typescript-eslint/explicit-member-accessibility": ["warn", { "accessibility": "no-public" }],
     "@typescript-eslint/init-declarations": ["off"],
     "@typescript-eslint/max-params": ["warn", { "max": 5 }],
-    "@typescript-eslint/no-confusing-void-expression": ["error", { "ignoreArrowShorthand": true, "ignoreVoidOperator": true }],
+    "@typescript-eslint/no-confusing-void-expression": ["warn", { "ignoreArrowShorthand": true, "ignoreVoidOperator": true }],
     "@typescript-eslint/no-empty-interface": ["warn", { "allowSingleExtends": true }],
     "@typescript-eslint/no-explicit-any": ["off"],
     "@typescript-eslint/no-inferrable-types": ["warn", { "ignoreParameters": true, "ignoreProperties": true }],
-    "@typescript-eslint/no-invalid-void-type": ["error", { "allowInGenericTypeArguments": true }],
-    "@typescript-eslint/no-magic-numbers": ["error", { "ignoreEnums": true, "ignoreNumericLiteralTypes": true, "ignoreReadonlyClassProperties": true, "ignoreArrayIndexes": true, "ignoreTypeIndexes": true, "ignore": [0, 1, 2, 4, 8, 16, 32, 64, 128, 192, 255, 256, 512, 1024, 2048, 4096, 8192] }],
+    "@typescript-eslint/no-invalid-void-type": ["warn", { "allowInGenericTypeArguments": true }],
+    "@typescript-eslint/no-magic-numbers": ["warn", { "ignoreEnums": true, "ignoreNumericLiteralTypes": true, "ignoreReadonlyClassProperties": true, "ignoreArrayIndexes": true, "ignoreTypeIndexes": true, "ignore": [0, 1, 2, 4, 8, 16, 32, 64, 128, 192, 255, 256, 512, 1024, 2048, 4096, 8192] }],
     "@typescript-eslint/no-restricted-imports": ["warn"],
-    "@typescript-eslint/no-unnecessary-condition": ["error", { "allowConstantLoopConditions": true }],
+    "@typescript-eslint/no-unnecessary-condition": ["warn", { "allowConstantLoopConditions": true }],
     "@typescript-eslint/no-unsafe-assignment": ["off"],
     "@typescript-eslint/no-unused-vars": ["warn", { "varsIgnorePattern": "^_", "argsIgnorePattern": "^_" }],
     "@typescript-eslint/no-use-before-define": ["off"],
     "@typescript-eslint/prefer-destructuring": ["off"],
-    "@typescript-eslint/restrict-template-expressions": ["error", { "allowNumber": true, "allowBoolean": true, "allowNullish": true }],
+    "@typescript-eslint/restrict-template-expressions": ["warn", { "allowNumber": true, "allowBoolean": true, "allowNullish": true }],
     "@typescript-eslint/sort-type-constituents": ["off"],
     "@typescript-eslint/method-signature-style": ["off"],
 
@@ -105,7 +105,7 @@
     "@typescript-eslint/prefer-readonly-parameter-types": ["off"],
     "@typescript-eslint/explicit-module-boundary-types": ["off"],
 
-    "@stylistic/brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+    "@stylistic/brace-style": ["warn", "stroustrup", { "allowSingleLine": true }],
     "@stylistic/explicit-module-boundary-types": ["off"],
     "@stylistic/newline-per-chained-call": ["off"],
     "@stylistic/no-extra-parens": ["off"],
@@ -121,41 +121,41 @@
 
     "import/consistent-type-specifier-style": ["off", "prefer-inline"],
     "import/newline-after-import": ["warn"],
-    "import/no-absolute-path": ["error"],
-    "import/no-anonymous-default-export": ["error"],
+    "import/no-absolute-path": ["warn"],
+    "import/no-anonymous-default-export": ["warn"],
     "import/no-cycle": ["off", { "ignoreExternal": true }],
     "import/no-duplicates": ["warn", { "prefer-inline": true }],
-    "import/no-empty-named-blocks": ["error"],
+    "import/no-empty-named-blocks": ["warn"],
     "import/no-extraneous-dependencies": ["off", { "devDependencies": false, "includeTypes": true }],
-    "import/no-mutable-exports": ["error"],
-    "import/no-named-default": ["error"],
-    "import/no-nodejs-modules": ["error"],
-    "import/no-self-import": ["error"],
-    "import/no-unassigned-import": ["error"],
+    "import/no-mutable-exports": ["warn"],
+    "import/no-named-default": ["warn"],
+    "import/no-nodejs-modules": ["warn"],
+    "import/no-self-import": ["warn"],
+    "import/no-unassigned-import": ["warn"],
     "import/no-useless-path-segments": ["warn"],
 
     /** misc */
     "@stylistic/lines-around-comment": ["warn", { "allowClassStart": true, "allowTypeStart": true }],
-    "@stylistic/array-bracket-newline": ["error", "consistent"],
-    "@stylistic/array-element-newline": ["error", "consistent"],
-    "@stylistic/dot-location": ["error", "property"],
+    "@stylistic/array-bracket-newline": ["warn", "consistent"],
+    "@stylistic/array-element-newline": ["warn", "consistent"],
+    "@stylistic/dot-location": ["warn", "property"],
     "@stylistic/function-call-argument-newline": ["warn", "consistent"],
     "@stylistic/function-paren-newline": ["warn", "consistent"],
-    "@stylistic/linebreak-style": ["error", "unix"],
+    "@stylistic/linebreak-style": ["warn", "unix"],
     "@stylistic/lines-between-class-members": ["warn", "always", { "exceptAfterSingleLine": true }],
     "@stylistic/object-property-newline": ["warn", { "allowAllPropertiesOnSameLine": true }],
     "@stylistic/operator-linebreak": ["warn", "before"],
-    "@stylistic/padded-blocks": ["error", "never"],
-    "@stylistic/quote-props": ["error", "consistent-as-needed"],
+    "@stylistic/padded-blocks": ["warn", "never"],
+    "@stylistic/quote-props": ["warn", "consistent-as-needed"],
     "@stylistic/quotes": ["warn", "single"],
-    "@stylistic/semi": ["error", "always"],
-    "@stylistic/multiline-ternary":  ["error", "always-multiline"],
+    "@stylistic/semi": ["warn", "always"],
+    "@stylistic/multiline-ternary":  ["warn", "always-multiline"],
     "@stylistic/generator-star-spacing": ["warn", { "before": false, "after": true }],
-    "@stylistic/indent": ["warn", 2],
+    "@stylistic/indent": ["off"],
     "@stylistic/max-len": ["off"],
     "@stylistic/object-curly-spacing": ["warn", "always"],
 
-    "@stylistic/member-delimiter-style": ["error", {
+    "@stylistic/member-delimiter-style": ["warn", {
       "multiline": {
         "delimiter": "comma",
         "requireLast": false

package/api/server/gateway.d.ts

@@ -1,13 +1,11 @@
 import 'urlpattern-polyfill';
 import type { HttpServerRequestContext } from '../../http/server/http-server.js';
-import type { HttpServerRequest } from '../../http/server/index.js';
-import { HttpServerResponse } from '../../http/server/index.js';
-import type { Resolvable } from '../../injector/index.js';
-import { resolveArgumentType } from '../../injector/index.js';
+import { HttpServerResponse, type HttpServerRequest } from '../../http/server/index.js';
+import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import type { Type } from '../../types.js';
-import type { AsyncMiddleware, AsyncMiddlewareNext } from '../../utils/middleware.js';
-import type { ApiController, ApiDefinition, ApiEndpointDefinition, ApiEndpointMethod, ApiEndpointServerImplementation } from '../types.js';
+import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../utils/middleware.js';
+import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import type { CorsMiddlewareOptions } from './middlewares/cors.middleware.js';
 export type ApiGatewayMiddlewareContext = {

package/function/log.d.ts

@@ -1,7 +1,8 @@
 import type { Logger } from '../logger/logger.js';
 export type WrapLogOptions = {
     fnName?: string;
+    logResult?: boolean;
     logger?: Logger;
     trace?: boolean;
 };
-export declare function wrapLog(fn: Function, { fnName, logger, trace }?: WrapLogOptions): Function;
+export declare function wrapLog(fn: Function, { fnName, logResult, logger, trace }?: WrapLogOptions): Function;

package/function/log.js

@@ -1,23 +1,28 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { isArray, isPrimitive, isString } from '../utils/type-guards.js';
 import { typeOf } from '../utils/type-of.js';
-export function wrapLog(fn, { fnName = fn.name, logger, trace = false } = {}) {
+export function wrapLog(fn, { fnName = fn.name, logResult = true, logger, trace = false } = {}) {
     const log = logger?.trace.bind(logger) ?? console.log.bind(console); // eslint-disable-line no-console
     const wrapped = {
         [fnName](...args) {
-            const argString = args.map((arg) => stringifyArg(arg)).join(', ');
+            const argString = args.map((arg) => stringifyValue(arg)).join(', ');
             log(`[call: ${fnName}(${argString})]`);
             if (trace) {
                 console.trace();
             }
-            return Reflect.apply(fn, this, args);
+            const result = Reflect.apply(fn, this, args);
+            if (logResult) {
+                const resultString = stringifyValue(result);
+                log(`[return: ${fnName} => ${resultString}]`);
+            }
+            return result;
         }
     };
     return wrapped[fnName];
 }
-function stringifyArg(arg, depth = 1) {
+function stringifyValue(arg, depth = 1) {
     if (isArray(arg) && (depth > 0)) {
-        const argString = arg.map((innerArg) => stringifyArg(innerArg, depth - 1)).join(', ');
+        const argString = arg.map((innerArg) => stringifyValue(innerArg, depth - 1)).join(', ');
         return `[${argString}]`;
     }
     return isPrimitive(arg) ? isString(arg) ? `"${arg}"` : String(arg) : typeOf(arg);

package/injector/decorators.d.ts

@@ -1,4 +1,4 @@
-import type { Decorator } from '../reflection/index.js';
+import { type Decorator } from '../reflection/index.js';
 import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../types.js';
 import type { Provider } from './provider.js';
 import type { InjectionToken } from './token.js';
@@ -6,9 +6,9 @@ import type { InjectMetadata } from './type-info.js';
 import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
 export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
 export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
-    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    /** Aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
     alias?: OneOrMany<InjectionToken>;
-    /** custom provider. Useful for example if initialization is required */
+    /** Custom provider. Useful for example if initialization is required */
     provider?: Provider<T, A, C>;
 };
 export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
@@ -24,58 +24,58 @@ export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecor
  */
 export declare function Injectable<T = any, A = any, C extends Record = Record>(options?: InjectableOptions<T, A, C>): ClassDecorator;
 /**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
 export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
 /**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
 export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
 /**
- * sets the token used to resolve the parameter
+ * Sets the token used to resolve the parameter
  * @param token token used for resolving
  * @param argument resolve argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
  */
 export declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
 /**
- * sets the token used to resolve the parameter. Resolves all providers
+ * Sets the token used to resolve the parameter. Resolves all providers
  * @param token token used for resolving
  * @param argument resolve argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
  */
 export declare function InjectAll<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
 /**
- * sets the argument used for resolving the parameter
+ * Sets the argument used for resolving the parameter
  * @param argument
  */
 export declare function ResolveArg<T>(argument: T): InjectDecorator;
 /**
- * sets the argument provider used for resolving the parameter
+ * Sets the argument provider used for resolving the parameter
  * @param argumentProvider
  */
 export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
 /**
- * injects the argument used for resolving the class instead of resolving the parameter
+ * Injects the argument used for resolving the class instead of resolving the parameter
  * @param argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
  */
 export declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
 /**
- * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * Sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
  * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
  */
 export declare function ForwardArg(): InjectDecorator;
 export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
 /**
- * marks the argument as optional
+ * Marks the argument as optional
  * @param argument
  */
 export declare function Optional(): InjectDecorator;
 /**
- * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
  * @param token token to resolve
  * @param argument resolve argument
  */

package/injector/decorators.js

@@ -34,21 +34,21 @@ export function Injectable(options = {}) {
     });
 }
 /**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
 export function Singleton(options = {}) {
     return Injectable({ ...options, lifecycle: 'singleton' });
 }
 /**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
 export function Scoped(lifecycle, options = {}) {
     return Injectable({ ...options, lifecycle });
 }
 /**
- * sets the token used to resolve the parameter
+ * Sets the token used to resolve the parameter
  * @param token token used for resolving
  * @param argument resolve argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
@@ -67,7 +67,7 @@ export function Inject(token, argument, mapperOrKey) {
     return createInjectDecorator(injectMetadata);
 }
 /**
- * sets the token used to resolve the parameter. Resolves all providers
+ * Sets the token used to resolve the parameter. Resolves all providers
  * @param token token used for resolving
  * @param argument resolve argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
@@ -86,21 +86,21 @@ export function InjectAll(token, argument, mapperOrKey) {
     return createInjectDecorator(injectMetadata);
 }
 /**
- * sets the argument used for resolving the parameter
+ * Sets the argument used for resolving the parameter
  * @param argument
  */
 export function ResolveArg(argument) {
     return ResolveArgProvider(() => argument);
 }
 /**
- * sets the argument provider used for resolving the parameter
+ * Sets the argument provider used for resolving the parameter
  * @param argumentProvider
  */
 export function ResolveArgProvider(argumentProvider) {
     return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
 }
 /**
- * injects the argument used for resolving the class instead of resolving the parameter
+ * Injects the argument used for resolving the class instead of resolving the parameter
  * @param argument
  * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
  */
@@ -117,14 +117,14 @@ export function ForwardArg(mapper = (value) => value) {
     return createInjectDecorator({ forwardArgumentMapper: mapper });
 }
 /**
- * marks the argument as optional
+ * Marks the argument as optional
  * @param argument
  */
 export function Optional() {
     return createInjectDecorator({ optional: true });
 }
 /**
- * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
  * @param token token to resolve
  * @param argument resolve argument
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.59",
+  "version": "0.90.61",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -109,11 +109,11 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.10"
+    "type-fest": "4.14"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "1.6",
+    "@stylistic/eslint-plugin": "1.7",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -129,8 +129,8 @@
     "tsc-alias": "1.8",
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.2",
-    "typescript": "5.3",
-    "typescript-eslint": "7.1"
+    "typescript": "5.4",
+    "typescript-eslint": "7.3"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.12",
@@ -145,12 +145,12 @@
     "koa": "^2.15",
     "minio": "^7.1",
     "mjml": "^4.15",
-    "mongodb": "^6.4",
+    "mongodb": "^6.5",
     "nodemailer": "^6.9",
     "playwright": "^1.42",
-    "preact": "^10.19",
+    "preact": "^10.20",
     "preact-render-to-string": "^6.4",
-    "undici": "^6.6",
+    "undici": "^6.10",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/signals/defer.d.ts

@@ -1,2 +1,2 @@
-import type { Signal } from './api.js';
+import { type Signal } from './api.js';
 export declare function defer<T>(signalFactory: () => Signal<T>): Signal<T>;

package/signals/implementation/effect.d.ts

@@ -21,19 +21,14 @@ export declare abstract class EffectScheduler {
      * It is an error to attempt to execute any effects synchronously during a scheduling operation.
      */
     abstract scheduleEffect(e: SchedulableEffect): void;
-}
-/**
- * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.
- */
-export interface FlushableEffectRunner {
     /**
      * Run any scheduled effects.
      */
-    flush(): void;
+    abstract flush(): void;
 }
-export declare class TstdlEffectScheduler implements EffectScheduler, FlushableEffectRunner {
+export declare class TstdlEffectScheduler implements EffectScheduler {
     private readonly queue;
-    private pendingFlush;
+    private hasPendingFlush;
     scheduleEffect(effect: SchedulableEffect): void;
     flush(): void;
 }

package/signals/implementation/effect.js

@@ -15,13 +15,16 @@ export class EffectScheduler {
 }
 export class TstdlEffectScheduler {
     queue = new Set();
-    pendingFlush = false;
+    hasPendingFlush = false;
     scheduleEffect(effect) {
+        if (this.queue.has(effect)) {
+            return;
+        }
         this.queue.add(effect);
-        if (!this.pendingFlush) {
-            this.pendingFlush = true;
+        if (!this.hasPendingFlush) {
+            this.hasPendingFlush = true;
             queueMicrotask(() => {
-                this.pendingFlush = false;
+                this.hasPendingFlush = false;
                 this.flush();
             });
         }

package/signals/implementation/signal.d.ts

@@ -44,7 +44,7 @@ export interface WritableSignal<T> extends Signal<T> {
     update(updateFn: (value: T) => T): void;
     /**
      * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
-     * but can't be changed using set, update or mutate methods. The readonly signals do _not_ have
+     * but can't be changed using set or update methods. The readonly signals do _not_ have
      * any built-in mechanism that would prevent deep-mutation of their value.
      */
     asReadonly(): Signal<T>;

package/utils/object/forward-ref.d.ts

@@ -10,7 +10,7 @@ export type ForwardRef<T extends object = object> = T & {
     [isForwardRef]: true;
 };
 export declare const ForwardRef: {
-    create<T extends object>(options?: ForwardRefOptions<T> | undefined): ForwardRef<T>;
+    create<T extends object>(options?: ForwardRefOptions<T>): ForwardRef<T>;
     isForwardRef<T_1 extends object = object>(value: any): value is ForwardRef<T_1>;
     hasRef<T_2 extends object>(forwardRef: T_2 | ForwardRef<T_2>): boolean;
     deref<T_3 extends object>(forwardRef: T_3 | ForwardRef<T_3>): T_3;