@tstdl/base 0.92.123 → 0.92.124

package/schema/schemas/literal.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export type LiteralSchemaOptions<T> = SchemaOptions<T>;
-export declare class LiteralSchema<const T> extends Schema<T> {
-    readonly name: string;
-    readonly value: T;
-    constructor(value: T, options?: LiteralSchemaOptions<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
-}
-export declare function literal<const T>(value: T, options?: LiteralSchemaOptions<T>): LiteralSchema<T>;
-export declare function Literal<const T>(value: T, options?: LiteralSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/never.d.ts

@@ -1,8 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export type NeverSchemaOptions = SchemaOptions<never>;
-export declare class NeverSchema extends Schema<never> {
-    readonly name = "never";
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never>;
-}
-export declare function never(options?: NeverSchemaOptions): NeverSchema;

package/schema/schemas/nullable.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { TypedOmit } from '../../types.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> {
-    readonly name: string;
-    readonly schema: Schema<T>;
-    constructor(schema: SchemaTestable<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
-}
-export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
-export declare function Nullable<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;

package/schema/schemas/number.d.ts

@@ -1,19 +0,0 @@
-import type { TypedOmit } from '../../types.js';
-import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type NumberSchemaOptions = SimpleSchemaOptions<number> & {
-    integer?: boolean;
-    minimum?: number;
-    maximum?: number;
-};
-export declare class NumberSchema extends SimpleSchema<number> {
-    readonly name: string;
-    readonly integer: boolean;
-    readonly minimum: number | null;
-    readonly maximum: number | null;
-    constructor(options?: NumberSchemaOptions);
-}
-export declare function number(options?: NumberSchemaOptions): NumberSchema;
-export declare function integer(options?: TypedOmit<NumberSchemaOptions, 'integer'>): NumberSchema;
-export declare function NumberProperty(options?: SchemaDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-export declare function Integer(options?: SchemaDecoratorOptions & TypedOmit<NumberSchemaOptions, 'integer'>): SchemaPropertyDecorator;

package/schema/schemas/object.d.ts

@@ -1,91 +0,0 @@
-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 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>;
-export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
-export type ObjectSchemaFactory<T> = {
-    type: Type<T>;
-} | ObjectSchemaFactoryFunction<T>;
-export type ObjectSchemaProperties<T extends Record = Record> = {
-    [P in keyof T]-?: SchemaTestable<T[P]>;
-};
-export type NormalizedObjectSchemaProperties<T extends Record> = {
-    [P in keyof T]-?: Schema<T[P]>;
-};
-export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = SchemaOptions<T> & {
-    name?: string;
-    mask?: boolean | null;
-    unknownPropertiesKey?: SchemaTestable<K> | null;
-    unknownProperties?: SchemaTestable<V> | null;
-    factory?: ObjectSchemaFactory<T> | null;
-};
-export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
-export type OptionalProperties<T> = {
-    [P in keyof T]: T[P] extends {
-        [OPTIONAL]: true;
-    } ? P : never;
-}[keyof T];
-export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
-    -readonly [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
-}>;
-export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
-export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
-    private readonly propertyKeys;
-    private readonly allowUnknownProperties;
-    readonly name: string;
-    readonly properties: NormalizedObjectSchemaProperties<T>;
-    readonly mask: boolean | null;
-    readonly unknownProperties: Schema | null;
-    readonly unknownPropertiesKey: Schema<PropertyKey> | null;
-    readonly factory: ObjectSchemaFactory<T> | null;
-    constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
-}
-export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
-    unknownProperties: SchemaTestable<V>;
-    unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<Partial<Record<K, V>>>;
-export declare function object<const K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
-    unknownProperties?: undefined;
-    unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<Partial<Record<K, unknown>>>;
-export declare function object<const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
-    unknownProperties: SchemaTestable<V>;
-    unknownPropertiesKey?: undefined;
-}): ObjectSchema<Partial<Record<PropertyKey, V>>>;
-export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
-    unknownProperties: SchemaTestable<V>;
-    unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
-export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
-    unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, unknown>>>;
-export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
-    unknownProperties: SchemaTestable<V>;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<PropertyKey, V>>>;
-export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
-    unknownProperties?: undefined;
-    unknownPropertiesKey?: undefined;
-}): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
-export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
-export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
-export declare function record<const K extends PropertyKey, const V>(keys: K[], value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
-export declare function record<const K extends PropertyKey, const V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Partial<Record<K, V>>>;
-export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
-export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
-export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
-export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
-export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record, const T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
-export declare function partial<const T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
-export declare function partial<const T extends Record, const K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
-export declare function pick<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
-export declare function omit<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
-export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
-declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
-export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
-export declare function Record<K extends PropertyKey, V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
-export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
-export {};

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

@@ -1,14 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { OneOrMany as OneOrManyType } from '../../types.js';
-import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]>;
-export type OneOrMany<T> = OneOrManyType<T>;
-export declare class OneOrManySchema<T> extends Schema<T | T[]> {
-    readonly name: string;
-    readonly schema: Schema<T | T[]>;
-    constructor(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | T[]>;
-}
-export declare function oneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T>): OneOrManySchema<T>;
-export declare function OneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/optional.d.ts

@@ -1,13 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { TypedOmit } from '../../types.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> {
-    readonly name: string;
-    readonly [OPTIONAL]: true;
-    readonly schema: Schema<T>;
-    constructor(schema: SchemaTestable<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;
-}
-export declare function optional<T>(schema: SchemaTestable<T>): OptionalSchema<T>;
-export declare function Optional<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'optional'>): SchemaPropertyDecorator;

package/schema/schemas/simple.d.ts

@@ -1,27 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { AbstractConstructor, OneOrMany } from '../../types.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;
-type SimpleSchemaRefinements<T> = {
-    coercers?: SimpleSchemaCoercers<T>;
-    constraints?: (SimpleSchemaConstraint<T> | null)[];
-    gotValueFormatter?: SimpleSchemaGotValueFormatter;
-};
-export type SimpleSchemaCoercers<T> = {
-    string?: (value: string, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    number?: (value: number, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    boolean?: (value: boolean, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    bigint?: (value: bigint, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    undefined?: (value: undefined, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    null?: (value: null, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-    all?: (value: unknown, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
-};
-export type SimpleSchemaConstraint<T> = (value: T) => ConstraintResult;
-export type SimpleSchemaGotValueFormatter = (value: unknown) => string;
-export declare abstract class SimpleSchema<T> extends Schema<T> {
-    #private;
-    constructor(expected: OneOrMany<string | AbstractConstructor>, guardFn: (value: any) => value is T, options?: SimpleSchemaOptions<T>, refinements?: SimpleSchemaRefinements<T>);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
-}
-export {};

package/schema/schemas/transform.d.ts

@@ -1,10 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export declare class TransformSchema<I, O> extends Schema<O> {
-    readonly name: string;
-    readonly schema: Schema<I>;
-    readonly transformFn: (value: I) => O;
-    constructor(schema: SchemaTestable<I>, transformFn: (value: I) => O);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<O>;
-}
-export declare function transform<I, O>(schema: Schema<I>, transformFn: (value: I) => O): TransformSchema<I, O>;

package/schema/schemas/union.d.ts

@@ -1,15 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-type UnionSchemaType<T extends [SchemaTestable, ...SchemaTestable[]]> = T[number] extends SchemaTestable<infer V> ? V : never;
-export declare class UnionSchema<T extends [SchemaTestable, ...SchemaTestable[]]> extends Schema<UnionSchemaType<T>> {
-    readonly name: string;
-    readonly schemas: {
-        [P in keyof T]: T[P] extends Schema ? T[P] : Schema<SchemaOutput<T[P]>>;
-    };
-    constructor(schemas: T);
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<UnionSchemaType<T>>;
-}
-export declare function union<T extends [SchemaTestable, ...SchemaTestable[]]>(...schemas: T): UnionSchema<T>;
-export declare function Union(...schemasAndOptions: [SchemaTestable, ...SchemaTestable[]] | [SchemaTestable, ...SchemaTestable[], options: SchemaDecoratorOptions]): SchemaPropertyDecorator;
-export {};

package/search-index/elastic/config.d.ts

@@ -1,8 +0,0 @@
-import type { Entity } from '../../database/index.js';
-import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-export type ElasticSearchIndexConfigArgument<T extends Entity = Entity> = string | ElasticSearchIndexConfig<T>;
-export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Resolvable<ElasticSearchIndexConfigArgument> {
-    readonly indexName: string;
-    readonly [resolveArgumentType]: ElasticSearchIndexConfigArgument<T>;
-    constructor(indexNameOrConfig: string | ElasticSearchIndexConfig<T>);
-}

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

@@ -1,26 +0,0 @@
-import type { Entity } from '../../../database/index.js';
-import type { DeepFlatten, StringMap, TypedOmit } from '../../../types.js';
-import type { estypes } from '@elastic/elasticsearch';
-export type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<estypes.MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
-export type ElasticNestedIndexMapping<T> = {
-    properties: {
-        [P in keyof Required<T>]: ElasticIndexMappingItem<DeepFlatten<Required<T>[P]>>;
-    };
-};
-type StrippedBaseType<T extends estypes.MappingPropertyBase> = TypedOmit<T, 'properties' | 'fields'>;
-type ElasticIndexMappingItemBase = {
-    index?: boolean;
-    fields?: StringMap<ElasticIndexMappingItem>;
-};
-export type MappingNumberProperty = estypes.MappingByteNumberProperty | estypes.MappingDoubleNumberProperty | estypes.MappingFloatNumberProperty | estypes.MappingHalfFloatNumberProperty | estypes.MappingIntegerNumberProperty | estypes.MappingLongNumberProperty | estypes.MappingShortNumberProperty | estypes.MappingScaledFloatNumberProperty | estypes.MappingUnsignedLongNumberProperty;
-export type ElasticKeywordIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingKeywordProperty>;
-export type ElasticTextIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingTextProperty>;
-export type ElasticNumberIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingNumberProperty>;
-export type ElasticBooleanIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingBooleanProperty>;
-export type ElasticDateIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingDateProperty>;
-export type ElasticGeoPointIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingGeoPointProperty>;
-export type ElasticObjectIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingObjectProperty> & ElasticNestedIndexMapping<T>;
-export type ElasticNestedIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingNestedProperty> & ElasticNestedIndexMapping<T>;
-export type ElasticIndexMappingItem<T = any> = ElasticKeywordIndexMappingItem | ElasticTextIndexMappingItem | ElasticNumberIndexMappingItem | ElasticBooleanIndexMappingItem | ElasticDateIndexMappingItem | ElasticGeoPointIndexMappingItem | ElasticObjectIndexMappingItem<T> | ElasticNestedIndexMappingItem<T>;
-export declare function mergeElasticSearchMappings<T extends Entity>(mappings: ElasticIndexMapping<T>[]): ElasticIndexMapping<T>;
-export {};

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

@@ -1,8 +0,0 @@
-import type { Entity } from '../../../database/index.js';
-import type { estypes } from '@elastic/elasticsearch';
-export type SortOrder = estypes.SortOrder;
-export type Sort<T extends Entity = Entity> = SortCombinations<T> | SortCombinations<T>[];
-export type SortCombinations<T extends Entity = Entity> = keyof T | SortOptions<T>;
-export type SortOptions<T extends Entity = Entity> = estypes.SortOptionsKeys & {
-    [P in keyof T]?: estypes.SortOptions[string];
-};

package/search-index/elastic/module.d.ts

@@ -1,10 +0,0 @@
-import type { ClientOptions } from '@elastic/elasticsearch';
-import type { ElasticSearchIndexConfigArgument } from './config.js';
-import { ElasticSearchIndexConfig } from './config.js';
-export type ElasticsearchModuleConfig = {
-    defaultOptions: ClientOptions;
-    logPrefix: string;
-};
-export declare const elasticsearchModuleConfig: ElasticsearchModuleConfig;
-export declare const ELASTIC_SEARCH_INDEX_CONFIG: import("../../injector/token.js").InjectionToken<ElasticSearchIndexConfig<import("../../database/entity.js").Entity>, ElasticSearchIndexConfigArgument>;
-export declare function configureElasticsearch(config?: Partial<ElasticsearchModuleConfig>): void;

package/search-index/elastic/query-converter.d.ts

@@ -1,9 +0,0 @@
-import type { Entity } from '../../database/index.js';
-import type { LogicalAndQuery, LogicalNorQuery, LogicalOrQuery, Query, TextSpanQueryMode } from '../../database/query.js';
-import type { estypes } from '@elastic/elasticsearch';
-import type { ElasticQuery } from './model/index.js';
-export declare function convertQuery<T extends Entity>(query: Query<T>): ElasticQuery;
-export declare function convertLogicalAndQuery<T extends Entity>(andQuery: LogicalAndQuery<T>['$and']): ElasticQuery;
-export declare function convertLogicalOrQuery<T extends Entity>(orQuery: LogicalOrQuery<T>['$or']): ElasticQuery;
-export declare function convertLogicalNorQuery<T extends Entity>(norQuery: LogicalNorQuery<T>['$nor']): ElasticQuery;
-export declare function convertTextSpanQueryMode(mode: TextSpanQueryMode | undefined): estypes.QueryDslTextQueryType | undefined;

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

@@ -1,31 +0,0 @@
-import type { Client } from '@elastic/elasticsearch';
-import type { Entity, Query, QueryOptions } from '../../database/index.js';
-import type { AfterResolve } from '../../injector/interfaces.js';
-import { afterResolve } from '../../injector/interfaces.js';
-import type { Logger } from '../../logger/index.js';
-import type { SearchResult } from '../../search-index/index.js';
-import { SearchIndex } from '../../search-index/index.js';
-import type { estypes } from '@elastic/elasticsearch';
-import type { ElasticSearchIndexConfig } from './config.js';
-import { KeywordRewriter } from './keyword-rewriter.js';
-import type { ElasticIndexMapping } from './model/index.js';
-export declare class ElasticSearchIndex<T extends Entity> extends SearchIndex<T> implements AfterResolve {
-    private readonly logger;
-    readonly client: Client;
-    readonly indexName: string;
-    readonly indexSettings: estypes.IndicesIndexSettings;
-    readonly indexMapping: ElasticIndexMapping<T>;
-    readonly keywordRewriter: KeywordRewriter;
-    constructor(client: Client, config: ElasticSearchIndexConfig<T>, indexSettings: estypes.IndicesIndexSettings, indexMapping: ElasticIndexMapping<T>, keywordRewrites: Iterable<string>, logger: Logger);
-    [afterResolve](): Promise<void>;
-    initialize(): Promise<void>;
-    refresh(): Promise<void>;
-    updateSettings(): Promise<void>;
-    index(entities: T[]): Promise<void>;
-    delete(id: string): Promise<void>;
-    deleteByQuery(query: Query<T>): Promise<void>;
-    search(searchQueryOrCursor: Query<T> | string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
-    drop(): Promise<void>;
-    exists(): Promise<boolean>;
-}

package/search-index/elastic/sort-converter.d.ts

@@ -1,4 +0,0 @@
-import type { Entity, Sort } from '../../database/index.js';
-import type { KeywordRewriter } from './keyword-rewriter.js';
-import type { SortCombinations } from './model/index.js';
-export declare function convertSort<T extends Entity>(sort: Sort<T>, keywordRewriter: KeywordRewriter): SortCombinations<T>;

package/search-index/error.d.ts

@@ -1,10 +0,0 @@
-import { CustomError } from '../errors/custom.error.js';
-export declare class SearchIndexError extends CustomError {
-    static readonly errorName = "SearchIndexError";
-    readonly type: string;
-    readonly raw: unknown;
-    constructor(type: string, message: string, { raw, cause }?: {
-        raw?: unknown;
-        cause?: Error;
-    });
-}

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

@@ -1,19 +0,0 @@
-import type { Entity, Query, QueryOptions } from '../../database/index.js';
-import { SearchIndex } from '../search-index.js';
-import type { SearchResult } from '../search-result.js';
-export declare class MemorySearchIndex<T extends Entity> extends SearchIndex<T> {
-    private readonly indexedFields;
-    private readonly allSet;
-    private readonly idMap;
-    private readonly indexMap;
-    constructor(indexedFields: (keyof T)[]);
-    index(entities: T[]): Promise<void>;
-    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>;
-    drop(): Promise<void>;
-    private _delete;
-    private indexEntity;
-    private deleteEntity;
-}

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

@@ -1,46 +0,0 @@
-import type { Entity } from '../database/entity.js';
-import type { Query, QueryOptions } from '../database/query.js';
-import type { SearchResult, SearchResultItem } from './search-result.js';
-export type SearchCursorOptions<T extends Entity> = QueryOptions<T> & {
-    batchSize?: number;
-};
-declare const type: unique symbol;
-export declare abstract class SearchIndex<T extends Entity> {
-    [type]: T;
-    /**
-     * search all entities using an automatic cursor
-     * @param query search query
-     * @param options search options
-     */
-    searchCursor(query: Query<T>, options?: SearchCursorOptions<T>): AsyncIterable<SearchResultItem<T>>;
-    /**
-     * search all entities instead of just a chunk
-     * @param query search query
-     * @param options search option
-     */
-    searchAll(query: Query<T>, options?: QueryOptions<T>): Promise<SearchResultItem<T>[]>;
-    /**
-     * index entities for search
-     * @param entities entities to index
-     */
-    abstract index(entities: T[]): Promise<void>;
-    /**
-     * delete entity from index
-     * @param id entity id to delete
-     */
-    abstract delete(id: string): Promise<void>;
-    /**
-     * delete matching entities from index
-     * @param query query to search for matching entities
-     */
-    abstract deleteByQuery(query: Query<T>): Promise<void>;
-    abstract search(query: Query<T>, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract search(cursor: string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract search(queryOrCursor: Query<T> | string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
-    abstract count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
-    /**
-     * drop index. If you only want to delete all items from the index, use {@link deleteByQuery} with an empty query.
-     */
-    abstract drop(): Promise<void>;
-}
-export {};

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

@@ -1,12 +0,0 @@
-import type { Entity } from '../database/index.js';
-export type SearchResultItem<T extends Entity> = {
-    entity: T;
-    score: number;
-};
-export type SearchResult<T extends Entity> = {
-    total?: number;
-    totalIsLowerBound: boolean;
-    milliseconds: number;
-    items: SearchResultItem<T>[];
-    cursor?: string;
-};

package/serializer/handlers/binary.d.ts

@@ -1,12 +0,0 @@
-import type { TypedArray } from '../../types.js';
-interface TypedArrayConstructor {
-    readonly BYTES_PER_ELEMENT: number;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): TypedArray;
-}
-export declare function serializeArrayBuffer(buffer: ArrayBuffer): string;
-export declare function deserializeArrayBuffer(data: string): ArrayBufferLike;
-export declare function serializeTypedArray(array: TypedArray): string;
-export declare function getTypedArrayDeserializer(constructor: TypedArrayConstructor): (data: string) => TypedArray;
-export declare function serializeBuffer(buffer: Buffer): string;
-export declare function deserializeBuffer(data: string): Buffer;
-export {};

package/serializer/serializable.d.ts

@@ -1,33 +0,0 @@
-import type { AbstractConstructor, Record, Type, TypedOmit } from '../types.js';
-export declare const Serializable: {
-    readonly serialize: unique symbol;
-    readonly deserialize: unique symbol;
-};
-export type DereferenceCallback = (dereferenced: unknown) => void;
-export type TryDereference = (value: unknown, callback: DereferenceCallback) => boolean;
-export interface Serializable<T, Data> {
-    [Serializable.serialize](instance: T, context: Record | undefined): Data;
-    [Serializable.deserialize](data: Data, tryDereference: TryDereference, context: Record | undefined): T;
-}
-export type SerializableType<T, Data> = Type<Serializable<T, Data>>;
-export type SerializeFunction<T, Data> = Serializable<T, Data>[typeof Serializable.serialize];
-export type DeserializeFunction<T, Data> = Serializable<T, Data>[typeof Serializable.deserialize];
-type SerializableRegistration<T = any, Data = any> = {
-    type: string;
-    serializeData?: boolean;
-    constructor: AbstractConstructor<T>;
-    serializer: SerializeFunction<T, Data>;
-    deserializer: DeserializeFunction<T, Data>;
-};
-export declare function getTypeNameByConstructor(constructor: AbstractConstructor): string | undefined;
-export declare function getSerializerByTypeName(typeName: string): SerializableRegistration | undefined;
-export declare function registerRawSerializable(constructor: AbstractConstructor): void;
-export declare function isRawSerializable(constructor: AbstractConstructor): boolean;
-export declare function serializable<T extends Serializable<any, Data>, Data>(typeName?: string): (target: SerializableType<T, Data>) => void;
-/**
- * register a serializable type for serialization
- * @param type class implementing {@link Serializable}
- */
-export declare function registerSerializable<T extends Serializable<any, Data>, Data>(type: SerializableType<T, Data>, typeName?: string): void;
-export declare function registerSerializer<T, Data>(constructor: AbstractConstructor<T>, typeName: string, serializer: SerializeFunction<T, Data>, deserializer: DeserializeFunction<T, Data>, options?: TypedOmit<SerializableRegistration, 'constructor' | 'deserializer' | 'serializer' | 'type'>): void;
-export {};

package/serializer/serializer.d.ts

@@ -1,20 +0,0 @@
-import { CircularBuffer } from '../data-structures/circular-buffer.js';
-import type { SerializationOptions, Serialized, StringSerialized } from './types.js';
-type QueueItem = () => void;
-export declare function stringSerialize<T>(value: T, options?: SerializationOptions): StringSerialized<T>;
-export declare function stringDeserialize<T = unknown>(serialized: string, options?: SerializationOptions): T;
-/**
- * serializes a value using decycling and deserialization of registered types
- * @param value value to serialize
- * @param options serialization options
- * @returns serialized representation of `value` which is safe to {@link JSON.stringify}
- */
-export declare function serialize<T>(value: T, options?: SerializationOptions): Serialized<T>;
-/**
- * for internal use only
- * @deprecated
- */
-export declare function serialize<T>(value: T, options: SerializationOptions, references: Map<any, string>, queue: CircularBuffer<QueueItem>, path: string): Serialized<T>;
-export declare function deserialize<T>(serialized: Serialized<T>, options?: SerializationOptions): T;
-export declare function deserialize(serialized: unknown, options?: SerializationOptions): unknown;
-export {};

package/serializer/types.d.ts

@@ -1,65 +0,0 @@
-import type { AbstractConstructor, JsonPrimitive, Nested, Record } from '../types.js';
-declare const serializedSymbol: unique symbol;
-declare const stringSerializedSymbol: unique symbol;
-declare const decycledSymbol: unique symbol;
-export type SerializationReplacer = (value: any, data?: Record) => any;
-export type TypeField<T extends string> = `<${T}>`;
-export type NonPrimitive<TypeName extends string = string, Data = unknown> = Record<TypeField<TypeName>, Data>;
-export type RawNonPrimitive = NonPrimitive<typeof rawNonPrimitiveType, any>;
-export type UndefinedNonPrimitive = NonPrimitive<typeof undefinedNonPrimitiveType, null>;
-export type BigintNonPrimitive = NonPrimitive<typeof bigintNonPrimitiveType, string>;
-export type GlobalSymbolNonPrimitive = NonPrimitive<typeof globalSymbolNonPrimitiveType, string>;
-export type FunctionNonPrimitive = NonPrimitive<typeof functionNonPrimitiveType, string>;
-export type RefNonPrimitive = NonPrimitive<typeof refNonPrimitiveType, string>;
-export type CustomNonPrimitive<TypeName extends string> = NonPrimitive<TypeName, SerializedData>;
-export type SerializedData = JsonPrimitive | NonPrimitive | Nested<JsonPrimitive | NonPrimitive>;
-export type Serialized<T = unknown> = SerializedData & {
-    [serializedSymbol]: T;
-};
-export type StringSerialized<T = unknown> = string & {
-    [stringSerializedSymbol]: T;
-};
-export type Decycled<T = unknown> = {
-    [decycledSymbol]: T;
-};
-export type SerializationOptions = {
-    /**
-     * !!! DANGEROUS !!!
-     *
-     * Enable de/serialization of stuff like functions
-     *
-     * Remote code execution possible, source must be trusted!
-     * @default false
-     */
-    allowUnsafe?: boolean;
-    /**
-     * Every replacer is called with every value and the value is replaced with its return value.
-     */
-    replacers?: SerializationReplacer[];
-    /**
-     * Constructors to not serialze (keep raw)
-     */
-    raws?: AbstractConstructor[];
-    /**
-     * Context for references. Can be used to reduce serialized size, if data is available at deserialization and to be able to reference abitrary data which is not serializable like non-global symbols
-     *
-     * Only first level of object is referenced. For example for `{ foo: { bar: 'baz' } }` there will be one context entry having { bar: 'baz' }
-     */
-    context?: Record;
-    /**
-     * Disables dereferencing of ForwardRefs. Only useful for debugging (when implementing custom serializers) and curiosity
-     * @default false
-     */
-    doNotDereferenceForwardRefs?: boolean;
-    /**
-     * Data to be used on de/serialization handlers and replacers
-     */
-    data?: Record;
-};
-export declare const rawNonPrimitiveType = "raw";
-export declare const undefinedNonPrimitiveType = "undefined";
-export declare const bigintNonPrimitiveType = "bigint";
-export declare const globalSymbolNonPrimitiveType = "global-symbol";
-export declare const functionNonPrimitiveType = "function";
-export declare const refNonPrimitiveType = "ref";
-export {};

package/sse/server-sent-events-source.d.ts

@@ -1,12 +0,0 @@
-import type { ServerSentJsonEvent, ServerSentTextEvent } from './model.js';
-export declare class ServerSentEventsSource {
-    #private;
-    readonly readable: ReadableStream<string>;
-    readonly closed: import("../signals/api.js").Signal<boolean>;
-    readonly error: import("../signals/api.js").Signal<Error | undefined>;
-    constructor();
-    close(): Promise<void>;
-    sendComment(comment: string): Promise<void>;
-    sendText({ name, data, id, retry }: ServerSentTextEvent): Promise<void>;
-    sendJson({ name, data, id, retry }: ServerSentJsonEvent): Promise<void>;
-}

package/templates/module.d.ts

@@ -1,14 +0,0 @@
-import type { Type } from '../types.js';
-import { TemplateProvider } from './template.provider.js';
-import { TemplateRenderer } from './template.renderer.js';
-import { TemplateResolver } from './template.resolver.js';
-export type TemplateModuleConfig = {
-    templateProvider: Type<TemplateProvider> | undefined;
-    templateResolvers: Type<TemplateResolver>[];
-    templateRenderers: Type<TemplateRenderer>[];
-};
-export declare const templateModuleConfig: TemplateModuleConfig;
-/**
- * configure mail module
- */
-export declare function configureTemplates(config?: Partial<TemplateModuleConfig>): void;

package/templates/providers/file.template-provider.d.ts

@@ -1,15 +0,0 @@
-import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import { Template } from '../template.model.js';
-import { TemplateProvider } from '../template.provider.js';
-export type FileTemplateProviderConfig = {
-    basePath?: string;
-};
-export type FileTemplateProviderArgument = string;
-export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
-export declare class FileTemplateProvider extends TemplateProvider implements Resolvable<FileTemplateProviderArgument> {
-    private readonly basePath;
-    readonly [resolveArgumentType]: FileTemplateProviderArgument;
-    constructor(basePath: string);
-    get<T extends Template = Template>(key: string): Promise<T>;
-}
-export declare function configureFileTemplateProvider(config?: Partial<FileTemplateProviderConfig>): void;