@tstdl/base 0.81.35 → 0.82.1

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

@@ -1,26 +1,26 @@
 import type { Entity } from "../../../database";
 import type { DeepFlatten, StringMap, TypedOmit } from "../../../types";
 import type { MappingBooleanProperty, MappingByteNumberProperty, MappingDateProperty, MappingDoubleNumberProperty, MappingFloatNumberProperty, MappingGeoPointProperty, MappingHalfFloatNumberProperty, MappingIntegerNumberProperty, MappingKeywordProperty, MappingLongNumberProperty, MappingNestedProperty, MappingObjectProperty, MappingPropertyBase, MappingScaledFloatNumberProperty, MappingShortNumberProperty, MappingTextProperty, MappingTypeMapping, MappingUnsignedLongNumberProperty } from '@elastic/elasticsearch/lib/api/types';
-export declare type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
-export declare type ElasticNestedIndexMapping<T> = {
+export type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
+export type ElasticNestedIndexMapping<T> = {
     properties: {
         [P in keyof Required<T>]: ElasticIndexMappingItem<DeepFlatten<Required<T>[P]>>;
     };
 };
-declare type StrippedBaseType<T extends MappingPropertyBase> = TypedOmit<T, 'properties' | 'fields'>;
-declare type ElasticIndexMappingItemBase = {
+type StrippedBaseType<T extends MappingPropertyBase> = TypedOmit<T, 'properties' | 'fields'>;
+type ElasticIndexMappingItemBase = {
     index?: boolean;
     fields?: StringMap<ElasticIndexMappingItem>;
 };
-export declare type MappingNumberProperty = MappingByteNumberProperty | MappingDoubleNumberProperty | MappingFloatNumberProperty | MappingHalfFloatNumberProperty | MappingIntegerNumberProperty | MappingLongNumberProperty | MappingShortNumberProperty | MappingScaledFloatNumberProperty | MappingUnsignedLongNumberProperty;
-export declare type ElasticKeywordIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingKeywordProperty>;
-export declare type ElasticTextIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingTextProperty>;
-export declare type ElasticNumberIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingNumberProperty>;
-export declare type ElasticBooleanIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingBooleanProperty>;
-export declare type ElasticDateIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingDateProperty>;
-export declare type ElasticGeoPointIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingGeoPointProperty>;
-export declare type ElasticObjectIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<MappingObjectProperty> & ElasticNestedIndexMapping<T>;
-export declare type ElasticNestedIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<MappingNestedProperty> & ElasticNestedIndexMapping<T>;
-export declare type ElasticIndexMappingItem<T = any> = ElasticKeywordIndexMappingItem | ElasticTextIndexMappingItem | ElasticNumberIndexMappingItem | ElasticBooleanIndexMappingItem | ElasticDateIndexMappingItem | ElasticGeoPointIndexMappingItem | ElasticObjectIndexMappingItem<T> | ElasticNestedIndexMappingItem<T>;
+export type MappingNumberProperty = MappingByteNumberProperty | MappingDoubleNumberProperty | MappingFloatNumberProperty | MappingHalfFloatNumberProperty | MappingIntegerNumberProperty | MappingLongNumberProperty | MappingShortNumberProperty | MappingScaledFloatNumberProperty | MappingUnsignedLongNumberProperty;
+export type ElasticKeywordIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingKeywordProperty>;
+export type ElasticTextIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingTextProperty>;
+export type ElasticNumberIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingNumberProperty>;
+export type ElasticBooleanIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingBooleanProperty>;
+export type ElasticDateIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingDateProperty>;
+export type ElasticGeoPointIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingGeoPointProperty>;
+export type ElasticObjectIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<MappingObjectProperty> & ElasticNestedIndexMapping<T>;
+export type ElasticNestedIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<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 +1,8 @@
 import type { Entity } from "../../../database";
 import type { SortOptions as ElasticSortOptions, SortOptionsKeys } from '@elastic/elasticsearch/lib/api/types';
 export type { SortOrder } from '@elastic/elasticsearch/lib/api/types';
-export declare type Sort<T extends Entity = Entity> = SortCombinations<T> | SortCombinations<T>[];
-export declare type SortCombinations<T extends Entity = Entity> = keyof T | SortOptions<T>;
-export declare type SortOptions<T extends Entity = Entity> = SortOptionsKeys & {
+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> = SortOptionsKeys & {
     [P in keyof T]?: ElasticSortOptions[string];
 };

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

@@ -2,7 +2,7 @@ import type { Entity } from "../../database";
 import type { ClientOptions } from '@elastic/elasticsearch';
 import type { ElasticSearchIndexConfigArgument } from './config';
 import { ElasticSearchIndexConfig } from './config';
-export declare type ElasticsearchModuleConfig = {
+export type ElasticsearchModuleConfig = {
     defaultOptions: ClientOptions;
     logPrefix: string;
 };

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

@@ -1,7 +1,7 @@
 import type { Entity } from "../database";
 import type { Query, QueryOptions } from "../database/query";
 import type { SearchResult, SearchResultItem } from './search-result';
-export declare type SearchCursorOptions<T extends Entity> = QueryOptions<T> & {
+export type SearchCursorOptions<T extends Entity> = QueryOptions<T> & {
     batchSize?: number;
 };
 declare const type: unique symbol;

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

@@ -1,9 +1,9 @@
 import type { Entity } from "../database";
-export declare type SearchResultItem<T extends Entity> = {
+export type SearchResultItem<T extends Entity> = {
     entity: T;
     score: number;
 };
-export declare type SearchResult<T extends Entity> = {
+export type SearchResult<T extends Entity> = {
     total?: number;
     totalIsLowerBound: boolean;
     milliseconds: number;

package/serializer/handlers/error.d.ts

@@ -1,4 +1,4 @@
-declare type ErrorData = Pick<Error, 'name' | 'message' | 'stack'>;
+type ErrorData = Pick<Error, 'name' | 'message' | 'stack'>;
 export declare function serializeError(error: Error): ErrorData;
 export declare function deserializeError(data: ErrorData): Error;
 export {};

package/serializer/handlers/map.d.ts

@@ -1,5 +1,5 @@
 import type { TryDereference } from '../serializable';
-declare type MapData = [any, any][];
+type MapData = [any, any][];
 export declare function serializeMap(map: Map<any, any>): MapData;
 export declare function deserializeMap(data: MapData, tryDereference: TryDereference): Map<any, any>;
 export {};

package/serializer/handlers/regex.d.ts

@@ -1,4 +1,4 @@
-declare type RegExpData = {
+type RegExpData = {
     pattern: string;
     flags: string;
 };

package/serializer/handlers/set.d.ts

@@ -1,6 +1,6 @@
 import type { TryDereference } from '../serializable';
 import type { Serialized } from '../types';
-declare type SetData = Serialized<any>[];
+type SetData = Serialized<any>[];
 export declare function serializeSet(set: Set<any>): SetData;
 export declare function deserializeSet(data: SetData, tryDereference: TryDereference): Set<any>;
 export {};

package/serializer/serializable.d.ts

@@ -3,16 +3,16 @@ export declare const Serializable: {
     readonly serialize: unique symbol;
     readonly deserialize: unique symbol;
 };
-export declare type DereferenceCallback = (dereferenced: unknown) => void;
-export declare type TryDereference = (value: unknown, callback: DereferenceCallback) => boolean;
+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): Data;
     [Serializable.deserialize](data: Data, tryDereference: TryDereference, context: Record): T;
 }
-export declare type SerializableType<T, Data> = Type<Serializable<T, Data>>;
-export declare type SerializeFunction<T, Data> = Serializable<T, Data>[typeof Serializable.serialize];
-export declare type DeserializeFunction<T, Data> = Serializable<T, Data>[typeof Serializable.deserialize];
-declare type SerializableRegistration<T = any, Data = any> = {
+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>;

package/serializer/serializer.d.ts

@@ -1,6 +1,6 @@
 import { CircularBuffer } from "../data-structures/circular-buffer";
 import type { SerializationOptions, Serialized, StringSerialized } from './types';
-declare type QueueItem = () => void;
+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;
 /**

package/serializer/types.d.ts

@@ -2,27 +2,27 @@ import type { AbstractConstructor, JsonPrimitive, Nested, Record, StringMap } fr
 declare const serializedSymbol: unique symbol;
 declare const stringSerializedSymbol: unique symbol;
 declare const decycledSymbol: unique symbol;
-export declare type SerializationReplacer = (value: any) => any;
-export declare type TypeField<T extends string> = `<${T}>`;
-export declare type NonPrimitive<TypeName extends string = string, Data = unknown> = Record<TypeField<TypeName>, Data>;
-export declare type RawNonPrimitive = NonPrimitive<typeof rawNonPrimitiveType, any>;
-export declare type UndefinedNonPrimitive = NonPrimitive<typeof undefinedNonPrimitiveType, null>;
-export declare type BigintNonPrimitive = NonPrimitive<typeof bigintNonPrimitiveType, string>;
-export declare type GlobalSymbolNonPrimitive = NonPrimitive<typeof globalSymbolNonPrimitiveType, string>;
-export declare type FunctionNonPrimitive = NonPrimitive<typeof functionNonPrimitiveType, string>;
-export declare type RefNonPrimitive = NonPrimitive<typeof refNonPrimitiveType, string>;
-export declare type CustomNonPrimitive<TypeName extends string> = NonPrimitive<TypeName, SerializedData>;
-export declare type SerializedData = JsonPrimitive | NonPrimitive | Nested<JsonPrimitive | NonPrimitive>;
-export declare type Serialized<T = unknown> = SerializedData & {
+export type SerializationReplacer = (value: any) => 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 declare type StringSerialized<T = unknown> = string & {
+export type StringSerialized<T = unknown> = string & {
     [stringSerializedSymbol]: T;
 };
-export declare type Decycled<T = unknown> = {
+export type Decycled<T = unknown> = {
     [decycledSymbol]: T;
 };
-export declare type SerializationOptions = {
+export type SerializationOptions = {
     /**
      * !!! DANGEROUS !!!
      *

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

@@ -1,4 +1,4 @@
-export declare type SeverSentEventsEventBase<Data> = {
+export type SeverSentEventsEventBase<Data> = {
     /**
      * Name of the event.
      */
@@ -16,8 +16,8 @@ export declare type SeverSentEventsEventBase<Data> = {
      */
     retry?: number;
 };
-export declare type SeverSentEventsTextEvent = SeverSentEventsEventBase<string>;
-export declare type SeverSentEventsJsonEvent = SeverSentEventsEventBase<any>;
+export type SeverSentEventsTextEvent = SeverSentEventsEventBase<string>;
+export type SeverSentEventsJsonEvent = SeverSentEventsEventBase<any>;
 export declare class SeverSentEvents {
     private readonly writable;
     private readonly writer;

package/tailwind/theme-adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Theme } from "../theme";
-export declare type TailwindPalette = {
+export type TailwindPalette = {
     DEFAULT: string;
     50: string;
     100: string;

package/templates/module.d.ts

@@ -2,7 +2,7 @@ import type { Type } from "../types";
 import { TemplateProvider } from './template.provider';
 import type { TemplateRenderer } from './template.renderer';
 import type { TemplateResolver } from './template.resolver';
-export declare type TemplateModuleConfig = {
+export type TemplateModuleConfig = {
     templateProvider: Type<TemplateProvider>;
     templateResolvers: Type<TemplateResolver>[];
     templateRenderers: Type<TemplateRenderer>[];

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

@@ -2,10 +2,10 @@ import type { Injectable } from "../../container";
 import { resolveArgumentType } from "../../container";
 import { Template } from '../template.model';
 import { TemplateProvider } from '../template.provider';
-export declare type FileTemplateProviderConfig = {
+export type FileTemplateProviderConfig = {
     basePath?: string;
 };
-export declare type FileTemplateProviderArgument = string;
+export type FileTemplateProviderArgument = string;
 export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
 export declare class FileTemplateProvider extends TemplateProvider implements Injectable<FileTemplateProviderArgument> {
     private readonly basePath;

package/templates/providers/file.provider-template.js

@@ -29,6 +29,7 @@ let FileTemplateProvider = class FileTemplateProvider extends template_provider_
         this.basePath = path.resolve(basePath);
     }
     async get(key) {
+        var _a;
         if (!keyPattern.test(key)) {
             throw new bad_request_error_1.BadRequestError('Illegal template key. Only a-z, A-Z, 0-9, _ and - are allowed.');
         }
@@ -36,7 +37,7 @@ let FileTemplateProvider = class FileTemplateProvider extends template_provider_
         if (!filePath.startsWith(this.basePath)) {
             throw new bad_request_error_1.BadRequestError(`Illegal file path. Must be inside "${this.basePath}".`);
         }
-        const templateModule = await Promise.resolve().then(() => require(filePath));
+        const templateModule = await (_a = filePath, Promise.resolve().then(() => require(_a)));
         const fileContent = templateModule.default;
         return schema_1.Schema.parse(template_model_1.Template, fileContent);
     }

package/templates/providers/file.provider-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"file.provider-template.js","sourceRoot":"","sources":["../../../source/templates/providers/file.provider-template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,+CAAwE;AACxE,qEAA4D;AAC5D,yCAAkC;AAClC,6BAA6B;AAC7B,sDAA6C;AAC7C,4DAAwD;AAQ3C,QAAA,0BAA0B,GAA+B,EAAE,CAAC;AAEzE,MAAM,UAAU,GAAG,aAAa,CAAC;AAK1B,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,oCAAgB;IACvC,QAAQ,CAAS;IAEzB,CAAC,+BAAmB,CAAC,CAA+B;IAC7D,YAAyB,QAAgB;QACvC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,mCAAe,CAAC,gEAAgE,CAAC,CAAC;SAC7F;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,MAAM,IAAI,mCAAe,CAAC,sCAAsC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;SACpF;QAED,MAAM,cAAc,GAAG,2CAAa,QAAQ,EAAyB,CAAC;QACtE,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC;QAC3C,OAAO,eAAM,CAAC,KAAK,CAAC,yBAAQ,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAzBY,oBAAoB;IAHhC,IAAA,qBAAS,EAAC;QACT,uBAAuB,EAAE,GAAG,EAAE,CAAC,kCAA0B,CAAC,QAAQ;KACnE,CAAC;IAKa,WAAA,IAAA,qBAAS,GAAE,CAAA;;GAJb,oBAAoB,CAyBhC;AAzBY,oDAAoB;AA2BjC,SAAgB,6BAA6B,CAAC,SAA8C,EAAE;IAC5F,kCAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,kCAA0B,CAAC,QAAQ,CAAC;AAC/F,CAAC;AAFD,sEAEC"}
+{"version":3,"file":"file.provider-template.js","sourceRoot":"","sources":["../../../source/templates/providers/file.provider-template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,+CAAwE;AACxE,qEAA4D;AAC5D,yCAAkC;AAClC,6BAA6B;AAC7B,sDAA6C;AAC7C,4DAAwD;AAQ3C,QAAA,0BAA0B,GAA+B,EAAE,CAAC;AAEzE,MAAM,UAAU,GAAG,aAAa,CAAC;AAK1B,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,oCAAgB;IACvC,QAAQ,CAAS;IAEzB,CAAC,+BAAmB,CAAC,CAA+B;IAC7D,YAAyB,QAAgB;QACvC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,GAAW;;QACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,mCAAe,CAAC,gEAAgE,CAAC,CAAC;SAC7F;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,MAAM,IAAI,mCAAe,CAAC,sCAAsC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;SACpF;QAED,MAAM,cAAc,GAAG,YAAa,QAAQ,4CAAyB,CAAC;QACtE,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC;QAC3C,OAAO,eAAM,CAAC,KAAK,CAAC,yBAAQ,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;CACF,CAAA;AAzBY,oBAAoB;IAHhC,IAAA,qBAAS,EAAC;QACT,uBAAuB,EAAE,GAAG,EAAE,CAAC,kCAA0B,CAAC,QAAQ;KACnE,CAAC;IAKa,WAAA,IAAA,qBAAS,GAAE,CAAA;;GAJb,oBAAoB,CAyBhC;AAzBY,oDAAoB;AA2BjC,SAAgB,6BAA6B,CAAC,SAA8C,EAAE;IAC5F,kCAA0B,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,kCAA0B,CAAC,QAAQ,CAAC;AAC/F,CAAC;AAFD,sEAEC"}

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

@@ -4,15 +4,15 @@ import { TemplateResolverProvider } from '../template-resolver.provider';
 import type { TemplateField } from '../template.model';
 import type { TemplateRenderObject } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type HandlebarsTemplateHelperOptionsLocationItem = {
+export type HandlebarsTemplateHelperOptionsLocationItem = {
     line: number;
     column: number;
 };
-export declare type HandlebarsTemplateHelperOptionsLocation = {
+export type HandlebarsTemplateHelperOptionsLocation = {
     start: HandlebarsTemplateHelperOptionsLocationItem;
     end: HandlebarsTemplateHelperOptionsLocationItem;
 };
-export declare type HandlebarsTemplateHelperOptions = {
+export type HandlebarsTemplateHelperOptions = {
     name: string;
     location?: HandlebarsTemplateHelperOptionsLocation;
     data?: Record<string>;
@@ -21,17 +21,17 @@ export declare type HandlebarsTemplateHelperOptions = {
     fn?: handlebars.TemplateDelegate;
     inverse?: handlebars.TemplateDelegate;
 };
-export declare type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
-export declare type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
-export declare type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | handlebars.TemplateDelegate;
-export declare type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
-export declare type HandlebarsRendererOptions = {
+export type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
+export type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
+export type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | handlebars.TemplateDelegate;
+export type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
+export type HandlebarsRendererOptions = {
     strict?: boolean;
     preventIndent?: boolean;
     helpers?: HandlebarsTemplateHelpersObject;
     partials?: HandlebarsTemplatePartialsObject;
 };
-export declare type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
+export type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
 export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
     private readonly templateResolverProvider;
     private readonly compileHandlebarsTemplate;

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

@@ -2,11 +2,11 @@ import type { MJMLParsingOptions } from 'mjml-core';
 import { TemplateRendererProvider } from '../template-renderer.provider';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
+export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
     preprocessorOptions?: any;
 };
-export declare type MjmlRendererString = 'mjml' | `mjml-${string}`;
-export declare type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions>;
+export type MjmlRendererString = 'mjml' | `mjml-${string}`;
+export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions>;
 export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
     private readonly rendererProvider;
     constructor(rendererProvider: TemplateRendererProvider);

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

@@ -1,6 +1,6 @@
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer';
 import { TemplateRenderer } from '../template.renderer';
-export declare type StringTemplateRenderObject = TemplateRenderObject<'string', undefined>;
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined>;
 export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
     constructor();
     canHandleType(type: string): boolean;

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

@@ -4,10 +4,10 @@ import { TypedOmit } from "../../types";
 import { TemplateField } from '../template.model';
 import { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer';
 import { TemplateResolver } from '../template.resolver';
-export declare type FileTemplateProviderConfig = {
+export type FileTemplateProviderConfig = {
     basePath?: string;
 };
-export declare type FileTemplateProviderArgument = string;
+export type FileTemplateProviderArgument = string;
 export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
 export declare class FileTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'file', Renderer, Options> {
     templateFile: string;

package/templates/template.model.d.ts

@@ -4,7 +4,7 @@ export declare class TemplateField<Resolver extends string = string, Renderer ex
     renderer: Renderer;
     options?: Options;
 }
-export declare type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
     [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options>;
 } & {
     [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;

package/templates/template.renderer.d.ts

@@ -1,11 +1,11 @@
-export declare type TemplateRenderResult = string;
-export declare type TemplateRenderObject<Renderer extends string = string, Options = any> = {
+export type TemplateRenderResult = string;
+export type TemplateRenderObject<Renderer extends string = string, Options = any> = {
     renderer: Renderer;
     template: string;
     options?: Options;
 };
-export declare type TemplateRendererString = typeof templateRendererString;
-export declare type TemplateRendererOptions = typeof templateRendererOptions;
+export type TemplateRendererString = typeof templateRendererString;
+export type TemplateRendererOptions = typeof templateRendererOptions;
 export declare const templateRendererString: unique symbol;
 export declare const templateRendererOptions: unique symbol;
 export declare abstract class TemplateRenderer<Renderer extends string = string, Options = any> {

package/templates/template.service.d.ts

@@ -3,7 +3,7 @@ import { TemplateRendererProvider } from './template-renderer.provider';
 import { TemplateResolverProvider } from './template-resolver.provider';
 import type { Template } from './template.model';
 import { TemplateProvider } from './template.provider';
-export declare type TemplateServiceRenderResult<T extends Template = Template> = {
+export type TemplateServiceRenderResult<T extends Template = Template> = {
     fields: Record<keyof T['fields'], string>;
     options: T['options'];
 };

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

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
 import type { LocalizableText } from './localizable-text.model';
 import { LocalizationService } from './localization.service';
-export declare type DynamicText = LocalizableText | Observable<LocalizableText>;
+export type DynamicText = LocalizableText | Observable<LocalizableText>;
 export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;

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

@@ -1,2 +1,2 @@
 import type { LocalizationData } from './localization.service';
-export declare type LocalizableText = string | LocalizationData;
+export type LocalizableText = string | LocalizationData;

package/text/localization.service.d.ts

@@ -1,20 +1,20 @@
 import type { Enumeration, EnumerationValue } from "../types";
 import type { PropertyName } from "../utils/object/property-name";
 import type { Observable } from 'rxjs';
-export declare type Language = {
+export type Language = {
     code: string;
     name: string;
 };
-export declare type LocalizeFunction<Parameters = void> = (parameters: Parameters) => string;
-export declare type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
-declare type LocalizationTemplate = {
+export type LocalizeFunction<Parameters = void> = (parameters: Parameters) => string;
+export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
+type LocalizationTemplate = {
     [key: string]: LocalizeItem<any> | LocalizationTemplate;
 };
-export declare type EnumerationLocalization<T extends Enumeration = Enumeration> = {
+export type EnumerationLocalization<T extends Enumeration = Enumeration> = {
     [P in EnumerationValue<T>]: LocalizeItem<any>;
 };
-export declare type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [T, EnumerationLocalization<T>];
-export declare type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = []> = {
+export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [T, EnumerationLocalization<T>];
+export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = []> = {
     language: Language;
     keys: T;
     enums: {
@@ -22,18 +22,18 @@ export declare type Localization<T extends LocalizationTemplate = LocalizationTe
     };
 };
 declare const parametersSymbol: unique symbol;
-export declare type LocalizationKey<Parameters = void> = PropertyName & {
+export type LocalizationKey<Parameters = void> = PropertyName & {
     [parametersSymbol]: Parameters;
 };
-export declare type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
+export type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
     key: LocalizationKey;
     parameters?: void;
 };
-export declare type LocalizationDataObject<Parameters> = {
+export type LocalizationDataObject<Parameters> = {
     key: LocalizationKey<Parameters>;
     parameters: Parameters;
 };
-export declare type LocalizationKeys<T extends LocalizationTemplate> = {
+export type LocalizationKeys<T extends LocalizationTemplate> = {
     [P in keyof T]: T[P] extends LocalizationTemplate ? LocalizationKeys<T[P]> : T[P] extends LocalizeItem<infer R> ? LocalizationKey<R> : LocalizationKey;
 };
 export declare function isLocalizationKey(value: any): value is LocalizationKey;

package/theme/theme-service.d.ts

@@ -1,30 +1,30 @@
 import type { UnionToTuple } from "../types";
 import type { Observable } from 'rxjs';
-export declare type CalculatedPalette<Colors extends string = string> = {
+export type CalculatedPalette<Colors extends string = string> = {
     [Color in Colors]: {
         main: ColorTones;
         text: ColorTones;
         border?: ColorTones;
     };
 };
-export declare type CalculatedTheme<Colors extends string = string> = {
+export type CalculatedTheme<Colors extends string = string> = {
     name: string;
     palette: CalculatedPalette<Colors>;
 };
-export declare type PaletteColor = string | {
+export type PaletteColor = string | {
     main: string;
     text?: string;
     border?: string;
 };
-export declare type Theme<Colors extends string = string> = {
+export type Theme<Colors extends string = string> = {
     name: string;
     textColors?: string[];
     palette: Palette<Colors>;
 };
-export declare type Palette<Colors extends string = string> = {
+export type Palette<Colors extends string = string> = {
     [Color in Colors]: PaletteColor;
 };
-export declare type ColorTones = {
+export type ColorTones = {
     base: string;
     50: string;
     100: string;

package/threading/thread-pool.d.ts

@@ -4,7 +4,7 @@ import { disposeAsync } from "../disposable";
 import type { Logger } from "../logger";
 import type * as NodeWorkerThreads from 'worker_threads';
 import type { ThreadWorker } from './thread-worker';
-export declare type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
+export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
     threadCount?: number;
 };
 export declare class ThreadPool implements AsyncDisposable {

package/threading/thread-worker.d.ts

@@ -1,3 +1,3 @@
 import type { RpcEndpointSource } from "../rpc";
-export declare type ThreadWorker = (...args: any[]) => any | Promise<any>;
+export type ThreadWorker = (...args: any[]) => any | Promise<any>;
 export declare function exposeThreadWorker<T extends ThreadWorker>(worker: T, endpointOrSource: RpcEndpointSource, name?: string): void;

package/types/geo-json.d.ts

@@ -1,36 +1,36 @@
 import type { JsonObject } from "../types";
-export declare type Position = [longitude: number, latitude: number, elevation?: number];
-export declare type GeoJsonObject<Type extends string> = {
+export type Position = [longitude: number, latitude: number, elevation?: number];
+export type GeoJsonObject<Type extends string> = {
     type: Type;
     bbox?: [number, number, number, number] | [number, number, number, number, number, number];
 };
-export declare type Point = GeoJsonObject<'Point'> & {
+export type Point = GeoJsonObject<'Point'> & {
     coordinates: Position;
 };
-export declare type LineString = GeoJsonObject<'LineString'> & {
+export type LineString = GeoJsonObject<'LineString'> & {
     coordinates: Position[];
 };
-export declare type Polygon = GeoJsonObject<'Polygon'> & {
+export type Polygon = GeoJsonObject<'Polygon'> & {
     coordinates: Position[][];
 };
-export declare type MultiPoint = GeoJsonObject<'MultiPoint'> & {
+export type MultiPoint = GeoJsonObject<'MultiPoint'> & {
     coordinates: Position[];
 };
-export declare type MultiLineString = GeoJsonObject<'MultiLineString'> & {
+export type MultiLineString = GeoJsonObject<'MultiLineString'> & {
     coordinates: Position[][];
 };
-export declare type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
+export type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
     coordinates: Position[][][];
 };
-export declare type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
+export type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
     geometries: Geometry[];
 };
-export declare type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
-export declare type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
+export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
+export type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
     id?: string | number;
     geometry: G;
     properties: P;
 };
-export declare type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
+export type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
     features: Feature<G, P>[];
 };