@tstdl/base 0.92.144 → 0.92.147

package/queue/provider.d.ts

@@ -1,4 +1,4 @@
-import type { ObjectLiteral } from '../types.js';
+import type { ObjectLiteral } from '../types/index.js';
 import type { Queue, QueueConfig } from './queue.js';
 export declare abstract class QueueProvider {
     abstract get<T extends ObjectLiteral>(key: string, config?: QueueConfig): Queue<T>;

package/reflection/decorators.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata/lite';
-import type { ConstructorParameterDecorator } from '../types.js';
+import type { ConstructorParameterDecorator } from '../types/index.js';
 import type { Decorator, DecoratorHandler } from './types.js';
 import { type CreateDecoratorOptions, type SpecificCreateDecoratorOptions } from './utils.js';
 export declare function Decorate({ handler, ...options }?: CreateDecoratorOptions & {

package/reflection/registry.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../types.js';
+import type { AbstractConstructor } from '../types/index.js';
 import { ContextDataMap } from '../data-structures/context-data-map.js';
 import type { DecoratorData } from './types.js';
 export type ReflectionMetadata = TypeMetadata | PropertyMetadata | MethodMetadata | ConstructorParameterMetadata | MethodParameterMetadata;

package/reflection/types.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, Record } from '../types.js';
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, Record } from '../types/index.js';
 import type { UnionToIntersection } from 'type-fest';
 import type { ConstructorParameterMetadata, MethodMetadata, MethodParameterMetadata, ParameterMetadata, PropertyMetadata, TypeMetadata } from './registry.js';
 export type DecoratorType = 'class' | 'property' | 'accessor' | 'method' | 'parameter' | 'methodParameter' | 'constructorParameter';

package/reflection/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../types.js';
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../types/index.js';
 import type { CombinedDecoratorParameters, Decorator, DecoratorData, DecoratorHandler, DecoratorMetadata, DecoratorType, DecoratorUnion } from './types.js';
 export type CreateDecoratorTypeOptions = Partial<Record<DecoratorType, boolean>>;
 export type CreateDecoratorOptions = {

package/rpc/model.d.ts

@@ -1,5 +1,5 @@
 import type { SerializationOptions } from '../serializer/types.js';
-import type { Constructor, Record } from '../types.js';
+import type { Constructor, Record } from '../types/index.js';
 export type RpcConstructor<T extends Constructor> = T extends Constructor<any, infer R> ? Constructor<Promise<RpcRemote<InstanceType<T>>>, R> : never;
 export type RpcFunction<T extends (...args: any) => any> = T extends (...args: infer Args) => infer R ? (...args: Args) => Promise<Awaited<R>> : never;
 export type RpcObject<T extends Record> = {

package/rxjs-utils/retry-backoff.js

@@ -7,7 +7,7 @@ export function retryBackoff(count, options) {
             throw error;
         }
         return counter + 1;
-    }, 0), delayWhen(() => timer(helper.backoff()))));
+    }, 0), delayWhen(() => timer(helper.getNextDelay()))));
 }
 export function retryBackoffHandled(count, options, handler) {
     return (source) => {
@@ -19,7 +19,7 @@ export function retryBackoffHandled(count, options, handler) {
                 return (returnValue != undefined) ? from(returnValue) : of(undefined);
             }
             return of(undefined);
-        }), delayWhen(() => timer(helper.backoff())))));
+        }), delayWhen(() => timer(helper.getNextDelay())))));
         return observable;
     };
 }

package/schema/converters/openapi-converter.d.ts

@@ -1,3 +1,3 @@
-import type { UndefinableJsonObject } from '../../types.js';
+import type { UndefinableJsonObject } from '../../types/index.js';
 import type { SchemaTestable } from '../schema.js';
 export declare function convertToOpenApiSchema(testable: SchemaTestable): UndefinableJsonObject;

package/schema/decorators/schema.d.ts

@@ -1,6 +1,6 @@
 import type { SetRequired } from 'type-fest';
 import { type Decorator } from '../../reflection/index.js';
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import type { SchemaTestable } from '../schema.js';
 import type { CombinedSchemaDecorator, SchemaReflectionData, SchemaTestableProvider } from './types.js';
 export type SchemaDecoratorOptions = SchemaReflectionData;

package/schema/decorators/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 import type { SchemaTestable } from '../schema.js';
 import type { SchemaReflectionData } from './types.js';
 export declare function schemaReflectionDataToSchema(reflectionData: SchemaReflectionData | undefined, fallbackType: AbstractConstructor | null, source: {

package/schema/schema.d.ts

@@ -1,6 +1,6 @@
 import type { IsEqual, Or } from 'type-fest';
 import { JsonPath } from '../json-path/json-path.js';
-import type { AbstractConstructor } from '../types.js';
+import type { AbstractConstructor } from '../types/index.js';
 import type { SchemaError } from './schema.error.js';
 import type { Coercible, Maskable } from './types.js';
 export type SchemaTestOptions = Coercible & Maskable & {

package/schema/schema.error.d.ts

@@ -1,6 +1,6 @@
 import { CustomError, type CustomErrorOptions } from '../errors/custom.error.js';
 import type { JsonPath } from '../json-path/index.js';
-import type { AbstractConstructor, OneOrMany, TypedOmit, UndefinableJson } from '../types.js';
+import type { AbstractConstructor, OneOrMany, TypedOmit, UndefinableJson } from '../types/index.js';
 import type { ErrorExtraInfo } from '../utils/format-error.js';
 export type SchemaErrorOptions = Pick<CustomErrorOptions, 'fast'> & {
     path: string | JsonPath;

package/schema/schemas/array.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 import type { Coercible } from '../types.js';

package/schema/schemas/enumeration.d.ts

@@ -1,4 +1,4 @@
-import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
+import type { Enumeration as EnumerationType, EnumerationValue } from '../../types/index.js';
 import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type EnumerationSchemaOptions<T extends EnumerationType> = SimpleSchemaOptions<EnumerationValue<T>>;

package/schema/schemas/function.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, Function } from '../../types.js';
+import type { AbstractConstructor, Function } from '../../types/index.js';
 import { type CombinedSchemaDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import type { Schema, SchemaTestable } from '../schema.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';

package/schema/schemas/instance.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;

package/schema/schemas/nullable.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class NullableSchema<T> extends Schema<T | null> {

package/schema/schemas/number.d.ts

@@ -1,4 +1,4 @@
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type NumberSchemaOptions = SimpleSchemaOptions<number> & {

package/schema/schemas/object.d.ts

@@ -1,7 +1,7 @@
 import type { EmptyObject, Merge } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import { type Decorator } from '../../reflection/index.js';
-import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types/index.js';
 import { type SchemaDecoratorOptions } from '../decorators/index.js';
 import { type OPTIONAL, Schema, type SchemaOptions, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;

package/schema/schemas/one-or-many.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { OneOrMany as OneOrManyType } from '../../types.js';
+import type { OneOrMany as OneOrManyType } from '../../types/index.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 import { type ArraySchemaOptions } from './array.js';

package/schema/schemas/optional.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { type OPTIONAL, Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class OptionalSchema<T> extends Schema<T | undefined> {

package/schema/schemas/simple.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { AbstractConstructor, OneOrMany } from '../../types.js';
+import type { AbstractConstructor, OneOrMany } from '../../types/index.js';
 import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 import type { CoerceResult, Coercible, ConstraintResult } from '../types.js';
 export type SimpleSchemaOptions<T> = SchemaOptions<T> & Coercible;

package/search-index/elastic/model/index-mapping.d.ts

@@ -1,6 +1,6 @@
 import type { estypes } from '@elastic/elasticsearch';
 import type { Entity } from '../../../database/index.js';
-import type { DeepFlatten, StringMap, TypedOmit } from '../../../types.js';
+import type { DeepFlatten, StringMap, TypedOmit } from '../../../types/index.js';
 export type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<estypes.MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
 export type ElasticNestedIndexMapping<T> = {
     properties: {

package/search-index/elastic/search-index.js

@@ -62,7 +62,7 @@ export class ElasticSearchIndex extends SearchIndex {
             operations: entities.flatMap((entity) => {
                 const { id: _, ...entityWithoutId } = entity;
                 return [{ index: { _id: entity.id } }, entityWithoutId];
-            })
+            }),
         };
         const result = await this.client.bulk(request);
         if (result.errors) {
@@ -84,7 +84,6 @@ export class ElasticSearchIndex extends SearchIndex {
         const queryBody = convertQuery(query);
         await this.client.deleteByQuery({ index: this.indexName, query: queryBody });
     }
-    // eslint-disable-next-line max-statements
     async search(searchQueryOrCursor, options) {
         const cursorData = isString(searchQueryOrCursor) ? deserializeCursor(searchQueryOrCursor) : undefined;
         const queryBody = isDefined(cursorData) ? cursorData.query : convertQuery(searchQueryOrCursor);
@@ -116,7 +115,7 @@ export class ElasticSearchIndex extends SearchIndex {
         }
         const result = await this.client.count({
             index: this.indexName,
-            query: convertQuery(query ?? {})
+            query: convertQuery(query ?? {}),
         });
         return result.count;
     }
@@ -128,7 +127,7 @@ export class ElasticSearchIndex extends SearchIndex {
         await this.client.indices.delete({ index: this.indexName });
     }
     async exists() {
-        return this.client.indices.exists({ index: this.indexName });
+        return await this.client.indices.exists({ index: this.indexName });
     }
 }
 function serializeCursor(query, sort, options, searchAfter) {

package/search-index/memory/memory-search-index.d.ts

@@ -11,7 +11,7 @@ export declare class MemorySearchIndex<T extends Entity> extends SearchIndex<T>
     delete(id: string): Promise<void>;
     deleteByQuery(query: Query<T>): Promise<void>;
     search(queryOrCursor: string | Query<T>, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    count(query?: Query<T>, options?: QueryOptions<T> | undefined): Promise<number>;
+    count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
     drop(): Promise<void>;
     private _delete;
     private indexEntity;

package/search-index/memory/memory-search-index.js

@@ -81,7 +81,7 @@ export class MemorySearchIndex extends SearchIndex {
             total: resultItems.length,
             totalIsLowerBound: false,
             milliseconds: timer.milliseconds,
-            items: resultItems
+            items: resultItems,
         };
         return result;
     }

package/serializer/handlers/binary.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray } from '../../types.js';
+import type { TypedArray } from '../../types/index.js';
 interface TypedArrayConstructor {
     readonly BYTES_PER_ELEMENT: number;
     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): TypedArray;

package/serializer/serializable.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, Record, Type, TypedOmit } from '../types.js';
+import type { AbstractConstructor, Record, Type, TypedOmit } from '../types/index.js';
 export declare const Serializable: {
     readonly serialize: unique symbol;
     readonly deserialize: unique symbol;

package/serializer/types.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, JsonPrimitive, Nested, Record } from '../types.js';
+import type { AbstractConstructor, JsonPrimitive, Nested, Record } from '../types/index.js';
 declare const serializedSymbol: unique symbol;
 declare const stringSerializedSymbol: unique symbol;
 declare const decycledSymbol: unique symbol;

package/templates/module.d.ts

@@ -1,4 +1,4 @@
-import type { Type } from '../types.js';
+import type { Type } from '../types/index.js';
 import { TemplateProvider } from './template.provider.js';
 import { TemplateRenderer } from './template.renderer.js';
 import { TemplateResolver } from './template.resolver.js';

package/templates/renderers/handlebars.template-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { ObjectLiteral, Record } from '../../types.js';
+import type { ObjectLiteral, Record } from '../../types/index.js';
 import type * as Handlebars from 'handlebars';
 import { TemplateResolverProvider } from '../template-resolver.provider.js';
 import type { TemplateField } from '../template.model.js';

package/templates/renderers/jsx.template-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
 import { TemplateRenderer } from '../template.renderer.js';

package/templates/renderers/mjml.template-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 import type { MJMLParsingOptions } from 'mjml-core';
 import { TemplateRendererProvider } from '../template-renderer.provider.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';

package/templates/renderers/string.template-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 import type { StringTemplate } from '../resolvers/string.template-resolver.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
 import { TemplateRenderer } from '../template.renderer.js';

package/templates/resolvers/file.template-resolver.d.ts

@@ -1,5 +1,5 @@
 import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types/index.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';

package/templates/resolvers/jsx.template-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { PartialProperty, Record, TypedOmit } from '../../types.js';
+import type { PartialProperty, Record, TypedOmit } from '../../types/index.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
 import { type Template, TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';

package/templates/resolvers/string.template-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { Record, TypedOmit } from '../../types.js';
+import type { Record, TypedOmit } from '../../types/index.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';

package/templates/template.model.d.ts

@@ -1,4 +1,4 @@
-import type { PickBy, Record, SimplifyObject } from '../types.js';
+import type { PickBy, Record, SimplifyObject } from '../types/index.js';
 export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
 declare const templateContext: unique symbol;
 export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {

package/templates/template.renderer.d.ts

@@ -1,5 +1,5 @@
 import type { SchemaTestable } from '../schema/index.js';
-import type { Record } from '../types.js';
+import type { Record } from '../types/index.js';
 export type TemplateRenderResult = string;
 export type TemplateRenderObject<Renderer extends string = string, Options = any, V = unknown> = {
     renderer: Renderer;

package/templates/template.service.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../types.js';
+import type { Record } from '../types/index.js';
 import { TemplateRendererProvider } from './template-renderer.provider.js';
 import { TemplateResolverProvider } from './template-resolver.provider.js';
 import type { Template, TemplateContext } from './template.model.js';

package/text/dynamic-text.model.d.ts

@@ -1,6 +1,6 @@
 import { type Observable } from 'rxjs';
 import { type Signal } from '../signals/api.js';
-import type { PickBy, ReactiveValue, ReplaceKey } from '../types.js';
+import type { PickBy, ReactiveValue, ReplaceKey } from '../types/index.js';
 import type { LocalizableText } from './localizable-text.model.js';
 import { LocalizationService } from './localization.service.js';
 export type DynamicText = ReactiveValue<LocalizableText>;

package/text/localization.service.d.ts

@@ -1,7 +1,7 @@
 import type { Observable } from 'rxjs';
 import { Logger } from '../logger/index.js';
 import type { Signal } from '../signals/api.js';
-import type { Enumeration, EnumerationValue, Record } from '../types.js';
+import type { Enumeration, EnumerationValue, Record } from '../types/index.js';
 import type { PropertyName } from '../utils/object/property-name.js';
 export type Language = {
     code: string;

package/types/geo-json.d.ts

@@ -1,4 +1,4 @@
-import type { JsonObject } from '../types.js';
+import type { JsonObject } from './types.js';
 export type Position = [longitude: number, latitude: number, elevation?: number];
 export type GeoJsonObject<Type extends string> = {
     type: Type;

package/types/index.d.ts

@@ -1,2 +1,4 @@
 export type * from './geo-json.js';
 export type * from './tagged.js';
+export type * from './types.js';
+export type * from './web-types.js';

package/types/tagged.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../types.js';
+import type { Record } from './types.js';
 export declare const tag: unique symbol;
 export declare const type: unique symbol;
 export type TagContainer<Type, Token> = {

package/{types.d.ts → types/types.d.ts}

@@ -1,6 +1,6 @@
 import type { Observable } from 'rxjs';
 import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
-import type { Signal } from './signals/api.js';
+import type { Signal } from '../signals/api.js';
 export type ObjectLiteral = {};
 export type Function<P extends any[] = any[], R = any> = (...params: P) => R;
 export type PrimitiveTypeMap = {
@@ -149,6 +149,7 @@ export type PickBy<T, V> = Pick<T, {
 export type NonNullable<T> = T extends null ? never : T;
 export type NonUndefinable<T> = T extends undefined ? never : T;
 export type NonNullOrUndefinable<T> = T extends null | undefined ? never : T;
+export type NoUnion<T> = [T] extends [boolean] ? boolean : [T] extends [UnionToIntersection<T>] ? T : never;
 /**
  * Makes optional properties required and removes null and undefined
  */

package/utils/async-hook/async-hook.d.ts

@@ -1,9 +1,118 @@
+/**
+ * Represents the public interface for an asynchronous hook.
+ *
+ * @template T The type of the value that the hook is triggered with.
+ * @template C The type of the optional context object passed to the hook's trigger and handlers. Defaults to `never`.
+ * @template R The return type of an individual handler. Defaults to `unknown`.
+ */
 export type AsyncHook<T, C = never, R = unknown> = {
+    /**
+     * Registers a handler function to be called when the hook is triggered.
+     * @param handler The async handler function to register.
+     * @returns A registration object with an `unregister` method to remove the handler.
+     */
     register: (handler: AsyncHookHandler<T, C, R>) => AsyncHookHandlerRegistration;
+    /**
+     * Triggers the hook, executing all registered handlers in sequence.
+     *
+     * The signature of this function is conditional:
+     * - If the context type `C` is `never` (the default), it accepts only the `value` argument.
+     * - If `C` is any other type, it requires both `value` and `context` arguments.
+     *
+     * @param value The value to pass to all handlers.
+     * @param context The context object to pass to all handlers (only required if `C` is not `never`).
+     * @returns A promise that resolves to an array of results from all handlers.
+     */
     trigger: [C] extends [never] ? ((value: T) => Promise<R[]>) : ((value: T, context: C) => Promise<R[]>);
 };
+/**
+ * Defines the signature for a handler function that can be registered with an `AsyncHook`.
+ * The function can be synchronous (returning `R`) or asynchronous (returning `Promise<R>`).
+ *
+ * The signature is conditional based on the context type `C`:
+ * - If `C` is `never`, the handler receives only the `value` argument.
+ * - If `C` is any other type, the handler receives both `value` and `context`.
+ *
+ * @template T The type of the value passed to the handler.
+ * @template C The type of the optional context object.
+ * @template R The expected return type of the handler.
+ */
 export type AsyncHookHandler<T, C, R> = [C] extends [never] ? ((value: T) => R | Promise<R>) : ((value: T, context: C) => R | Promise<R>);
+/**
+ * Represents the object returned when a handler is registered,
+ * allowing for its subsequent unregistration.
+ */
 export type AsyncHookHandlerRegistration = {
+    /**
+     * Unregisters the handler, preventing it from being called in future triggers.
+     */
     unregister: () => void;
 };
+/**
+ * Creates a new asynchronous hook.
+ *
+ * An async hook is a system that allows you to register multiple "handler" functions
+ * that will be executed in sequence when a "trigger" event occurs. This is useful
+ * for creating extensible, plugin-like architectures. Handlers can be synchronous
+ * or asynchronous.
+ *
+ * @template T The type of the primary value that the hook is triggered with.
+ * @template C The type of the optional context object passed to the hook's trigger and handlers. Defaults to `never`.
+ * @template R The return type of an individual handler. The `trigger` method will resolve with an array of these values (`R[]`). Defaults to `unknown`.
+ * @returns {AsyncHook<T, C, R>} An object with `register` and `trigger` methods.
+ *
+ * @example
+ * ```ts
+ * // Simple hook without context
+ * async function runSimpleExample() {
+ *   const onTaskStart = asyncHook<string>();
+ *
+ *   onTaskStart.register(taskName => {
+ *     console.log(`[Logger] Task started: ${taskName}`);
+ *   });
+ *
+ *   const registration = onTaskStart.register(async taskName => {
+ *     await new Promise(resolve => setTimeout(resolve, 50));
+ *     console.log(`[Notifier] Notifying that task started: ${taskName}`);
+ *   });
+ *
+ *   await onTaskStart.trigger('Process Data');
+ *   // [Logger] Task started: Process Data
+ *   // [Notifier] Notifying that task started: Process Data
+ *
+ *   registration.unregister();
+ *   console.log('Notifier unregistered.');
+ *
+ *   await onTaskStart.trigger('Finalize Report');
+ *   // [Logger] Task started: Finalize Report
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Hook with a context object
+ * async function runContextExample() {
+ *   type TaskContext = { userId: number; transactionId: string };
+ *
+ *   const onTaskComplete = asyncHook<string, TaskContext, boolean>();
+ *
+ *   onTaskComplete.register((taskName, context) => {
+ *     console.log(`[Audit] Task '${taskName}' completed by user ${context.userId}.`);
+ *     return true; // Audit successful
+ *   });
+ *
+ *   onTaskComplete.register(async (taskName, context) => {
+ *     console.log(`[DB] Logging completion of '${taskName}' for transaction ${context.transactionId}.`);
+ *     return true; // DB update successful
+ *   });
+ *
+ *   const results = await onTaskComplete.trigger(
+ *     'SubmitOrder',
+ *     { userId: 123, transactionId: 'abc-456' }
+ *   );
+ *
+ *   console.log('Handler results:', results); // [true, true]
+ * }
+ * ```
+ */
 export declare function asyncHook<T, C = never, R = unknown>(): AsyncHook<T, C, R>;