@tstdl/base 0.92.123 → 0.92.124

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

@@ -0,0 +1,46 @@
+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/types/search-index/search-result.d.ts

@@ -0,0 +1,12 @@
+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/types/serializer/handlers/binary.d.ts

@@ -0,0 +1,12 @@
+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/types/serializer/serializable.d.ts

@@ -0,0 +1,33 @@
+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/types/serializer/serializer.d.ts

@@ -0,0 +1,20 @@
+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/types/serializer/types.d.ts

@@ -0,0 +1,65 @@
+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/types/sse/server-sent-events-source.d.ts

@@ -0,0 +1,12 @@
+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/types/templates/module.d.ts

@@ -0,0 +1,14 @@
+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/types/templates/providers/file.template-provider.d.ts

@@ -0,0 +1,15 @@
+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;

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

@@ -0,0 +1,43 @@
+import type { ObjectLiteral, Record } from '../../../types.js';
+import type * as Handlebars from 'handlebars';
+import { TemplateResolverProvider } from '../template-resolver.provider.js';
+import type { TemplateField } from '../template.model.js';
+import type { TemplateRenderObject } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type HandlebarsTemplateHelperOptionsLocationItem = {
+    line: number;
+    column: number;
+};
+export type HandlebarsTemplateHelperOptionsLocation = {
+    start: HandlebarsTemplateHelperOptionsLocationItem;
+    end: HandlebarsTemplateHelperOptionsLocationItem;
+};
+export type HandlebarsTemplateHelperOptions = {
+    name: string;
+    location?: HandlebarsTemplateHelperOptionsLocation;
+    data?: Record<string>;
+    hash: Record<string>;
+    lookupProperty: (object: ObjectLiteral, propertyName: string) => unknown;
+    fn?: Handlebars.TemplateDelegate;
+    inverse?: Handlebars.TemplateDelegate;
+};
+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 type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
+export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
+    private readonly templateResolverProvider;
+    private readonly compileHandlebarsTemplate;
+    constructor(templateResolverProvider: TemplateResolverProvider);
+    canHandleType(type: string): boolean;
+    _render(renderObject: HandlebarsTemplateRenderObject, context: Record): Promise<string>;
+    private _compileHandlebarsTemplate;
+    private normalizePartial;
+}

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

@@ -0,0 +1,10 @@
+import type { Record } from '../../../types.js';
+import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, JsxTemplate>;
+export declare class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
+    constructor();
+    canHandleType(type: string): boolean;
+    _render({ template }: JsxTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

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

@@ -0,0 +1,16 @@
+import type { Record } from '../../../types.js';
+import type { MJMLParsingOptions } from 'mjml-core';
+import { TemplateRendererProvider } from '../template-renderer.provider.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
+    preprocessorOptions?: any;
+};
+export type MjmlRendererString = 'mjml' | `mjml-${string}`;
+export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions, string>;
+export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
+    private readonly rendererProvider;
+    constructor(rendererProvider: TemplateRendererProvider);
+    canHandleType(type: string): boolean;
+    _render({ renderer, template, options }: MjmlTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

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

@@ -0,0 +1,10 @@
+import type { Record } from '../../../types.js';
+import type { StringTemplate } from '../resolvers/string.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, StringTemplate>;
+export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
+    constructor();
+    canHandleType(type: string): boolean;
+    _render({ template }: StringTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
+}

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

@@ -0,0 +1,22 @@
+import { type Resolvable, resolveArgumentType } from '../../../injector/interfaces.js';
+import type { TypedOmit } from '../../../types.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type FileTemplateProviderConfig = {
+    basePath?: 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;
+}
+export declare class FileTemplateResolver extends TemplateResolver<FileTemplateField> implements Resolvable<FileTemplateProviderArgument> {
+    private readonly basePath;
+    readonly [resolveArgumentType]: FileTemplateProviderArgument;
+    constructor(basePath: string);
+    canHandle(resolver: string): boolean;
+    resolve(field: FileTemplateField): Promise<string>;
+}
+export declare function fileTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function configureFileTemplateResolver(config?: Partial<FileTemplateProviderConfig>): void;

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

@@ -0,0 +1,17 @@
+import type { PartialProperty, Record, TypedOmit } from '../../../types.js';
+import type { ComponentClass, FunctionComponent } from 'preact';
+import { type Template, TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
+export declare class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: JsxTemplate<Context>;
+}
+export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
+    canHandle(resolver: string): boolean;
+    resolve(field: JsxTemplateField): JsxTemplate;
+}
+export declare function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: PartialProperty<TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>, 'renderer'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;
+export declare function simpleJsxTemplate<Context extends Record = any>(name: string, template: JsxTemplate<Context>): Template<{
+    template: true;
+}, undefined, Context>;

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

@@ -0,0 +1,13 @@
+import type { Record, TypedOmit } from '../../../types.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
+export declare class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: StringTemplate<Context>;
+}
+export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
+    canHandle(resolver: string): boolean;
+    resolve(field: StringTemplateField): StringTemplate<Record>;
+}
+export declare function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

package/types/templates/template.model.d.ts

@@ -0,0 +1,25 @@
+import type { PickBy, Record, SimplifyObject } from '../../types.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> {
+    readonly [templateContext]?: (context: Context) => void;
+    resolver: Resolver;
+    renderer: Renderer;
+    options?: Options;
+}
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<{
+    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>;
+} & {
+    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>;
+}>;
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
+    /** Name of template */
+    name: string;
+    fields: TemplateFields<Fields, string, string, any, Context>;
+    options?: TemplateOptions;
+}
+export declare function simpleTemplate<Context extends Record = any, Options = any>(name: string, template: TemplateField<string, string, any, Context>, options?: Options): Template<{
+    template: true;
+}, Options, Context>;
+export {};

package/types/templates/template.renderer.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaTestable } from '../../schema/index.js';
+import type { Record } from '../../types.js';
+export type TemplateRenderResult = string;
+export type TemplateRenderObject<Renderer extends string = string, Options = any, V = unknown> = {
+    renderer: Renderer;
+    template: V;
+    contextSchema?: SchemaTestable<Record>;
+    options?: Options;
+};
+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> {
+    readonly [templateRendererString]: Renderer;
+    readonly [templateRendererOptions]: Options;
+    render(template: TemplateRenderObject<Renderer, Options>, context?: Record): Promise<TemplateRenderResult>;
+    abstract canHandleType(type: string): boolean;
+    protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context: Record): TemplateRenderResult | Promise<TemplateRenderResult>;
+}

package/types/templates/template.service.d.ts

@@ -0,0 +1,18 @@
+import type { Record } from '../../types.js';
+import { TemplateRendererProvider } from './template-renderer.provider.js';
+import { TemplateResolverProvider } from './template-resolver.provider.js';
+import type { Template, TemplateContext } from './template.model.js';
+import { TemplateProvider } from './template.provider.js';
+export type TemplateServiceRenderResult<T extends Template = Template> = {
+    name: string;
+    fields: Record<keyof T['fields'], string>;
+    options: T['options'];
+};
+export declare class TemplateService {
+    private readonly templateProvider;
+    private readonly templateRendererProvider;
+    private readonly templateResolverProvider;
+    constructor(templateProvider: TemplateProvider | undefined, templateRendererProvider: TemplateRendererProvider, templateResolverProvider: TemplateResolverProvider);
+    get<T extends Template = Template>(key: string): Promise<T>;
+    render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>>;
+}

package/types/templates/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateRenderer } from './template.renderer.js';
+import type { TemplateResolver } from './template.resolver.js';
+export declare const TEMPLATE_RENDERERS: import("../../injector/token.js").InjectionToken<TemplateRenderer<string, any>[], never>;
+export declare const TEMPLATE_RESOLVERS: import("../../injector/token.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any, any>, unknown>[], never>;

package/types/test.d.ts

@@ -0,0 +1 @@
+import '../polyfills.js';

package/types/test2.d.ts

@@ -0,0 +1 @@
+import '../polyfills.js';

package/types/test3.d.ts

@@ -0,0 +1 @@
+import '../polyfills.js';

package/types/test4.d.ts

@@ -0,0 +1,21 @@
+import '../polyfills.js';
+import type { DocumentCollection, DocumentWorkflowStep } from './document-management/index.js';
+import { DocumentManagementAncillaryService, type DocumentCollectionMetadata } from './document-management/server/index.js';
+export declare class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
+    _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[];
+    canReadCollection(_collectionId: string, _token?: unknown): boolean;
+    canWriteCollection(_collectionId: string, _token?: unknown): boolean;
+    canApproveDocument(_documentId: string, _token?: unknown): boolean;
+    canRejectDocument(_documentId: string, _token?: unknown): boolean;
+    canReadDocumentRequest(_requestId: string, _token?: unknown): boolean;
+    canAssignDocumentToRequest(_requestId: string, _documentId: string, _token?: unknown): boolean;
+    canManageCategoriesAndTypes(_token?: unknown): boolean;
+    canReadDocumentRequestsTemplates(_token?: unknown): boolean;
+    canManageDocumentRequestsTemplates(_token?: unknown): boolean;
+    canCreateUnassignedDocument(_token?: unknown): boolean;
+    canCreateRequestAssignedDocument(_token?: unknown): boolean;
+    canDeleteDocument(_documentId: string, _token?: unknown): boolean;
+    canManageDocumentRequest(_token?: unknown): boolean;
+    canManageValidationDefinitions(_token?: unknown): boolean;
+    canProgressDocumentWorkflow(_documentId: string, _currentWorkflowStep: DocumentWorkflowStep, _token?: unknown): boolean;
+}

package/types/test5.d.ts

@@ -0,0 +1 @@
+import '../polyfills.js';

package/types/test6.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import { type Observable } from 'rxjs';
+import { type Signal } from '../../signals/api.js';
+import type { PickBy, ReactiveValue, ReplaceKey } from '../../types.js';
+import type { LocalizableText } from './localizable-text.model.js';
+import { LocalizationService } from './localization.service.js';
+export type DynamicText = ReactiveValue<LocalizableText>;
+export declare const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
+export declare function resolveDynamicText(text: DynamicText, localizationService?: LocalizationService): Signal<string>;
+export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;
+export declare function resolveDynamicTexts(texts: DynamicText[], localizationService?: LocalizationService): Signal<string[]>;
+export declare function resolveDynamicTexts$(texts: DynamicText[], localizationService?: LocalizationService): Observable<string[]>;
+export declare function resolveNestedDynamicText<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>>;
+export declare function resolveNestedDynamicText$<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>>;
+export declare function resolveNestedDynamicTexts<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>[]>;
+export declare function resolveNestedDynamicTexts$<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>[]>;

package/types/text/localization.service.d.ts

@@ -0,0 +1,92 @@
+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 { PropertyName } from '../../utils/object/property-name.js';
+export type Language = {
+    code: string;
+    name: string;
+};
+export type LocalizeFunctionContext = {
+    localizationService: LocalizationService;
+};
+export type LocalizeFunction<Parameters = void> = (parameters: Parameters, context: LocalizeFunctionContext) => string;
+export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
+type LocalizationTemplate = {
+    [key: string]: LocalizeItem<any> | LocalizationTemplate;
+};
+export type EnumerationLocalization<T extends Enumeration = Enumeration> = Record<EnumerationValue<T>, LocalizeItem<any>>;
+export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [enumType: T, enumName: LocalizeItem<any> | undefined, enumValues: EnumerationLocalization<T>];
+export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = Enumeration[]> = {
+    language: Language;
+    keys: T;
+    enums: {
+        [I in keyof Enums]: EnumerationLocalizationEntry<Enums[I]>;
+    };
+};
+declare const parametersSymbol: unique symbol;
+export type ProxyLocalizationKey<Parameters = void> = PropertyName & {
+    [parametersSymbol]?: Parameters;
+};
+export type LocalizationKey<Parameters = void> = string | ProxyLocalizationKey<Parameters>;
+export type EnumLocalizationKey<T extends Enumeration = Enumeration, Parameters = void> = Parameters extends void ? {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters?: void;
+} : {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters: Parameters;
+};
+export type LocalizationData<Parameters = any, E extends Enumeration = any> = LocalizationKey | EnumLocalizationKey<E, Parameters> | LocalizationDataObject<Parameters> | {
+    key: LocalizationKey;
+    parameters?: void;
+};
+export type LocalizationDataObject<Parameters> = {
+    key: LocalizationKey<Parameters>;
+    parameters: Parameters;
+};
+export type ProxyLocalizationKeys<T extends LocalizationTemplate> = {
+    [P in keyof T]: T[P] extends LocalizationTemplate ? ProxyLocalizationKeys<T[P]> : T[P] extends LocalizeItem<infer R> ? ProxyLocalizationKey<R> : ProxyLocalizationKey;
+};
+export declare function getProxyLocalizationKey<Parameters = void>(key: string): ProxyLocalizationKey<Parameters>;
+export declare function isProxyLocalizationKey(value: any): value is ProxyLocalizationKey;
+export declare function isEnumLocalizationKey(key: any): key is EnumLocalizationKey;
+export declare function isLocalizationDataObject(value: LocalizationData): value is LocalizationDataObject<any>;
+/** helper function to ensure type safety */
+export declare function localizationData<T>(key: LocalizationKey<T>, parameters: T): LocalizationDataObject<T>;
+export declare function localizationData<T>(data: LocalizationData<T>): LocalizationDataObject<T>;
+/**
+ * returns a Proxy which simply returns the key you accessed. Can be used to have typesafe localizations (in templates and the API) by not relying on plain strings
+ * @param localization
+ * @returns
+ */
+export declare function getLocalizationKeys<T extends Localization>(_localization?: T): ProxyLocalizationKeys<T['keys']>;
+export declare const autoEnumerationLocalization: typeof _autoEnumerationLocalization;
+export declare class LocalizationService {
+    #private;
+    readonly activeLanguage: Signal<Language | null>;
+    readonly availableLanguages: Signal<Language[]>;
+    readonly activeLanguage$: Observable<Language | null>;
+    readonly availableLanguages$: Observable<Language[]>;
+    constructor(logger: Logger);
+    registerLocalization(...localizations: Localization[]): void;
+    hasLanguage(languageCode: string): boolean;
+    getLanguage(languageCode: string): Language;
+    setLanguage(languageOrCode: Language | string): void;
+    setLocalization(localization: Localization): void;
+    tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
+    hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
+    localizeOnce<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
+    localizeEnumOnce<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
+    localize<Parameters>(data: LocalizationData<Parameters>): Signal<string>;
+    localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Signal<string>;
+    localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
+    localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;
+    private localizeItem;
+}
+export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, name: LocalizeItem | undefined, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
+export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
+declare function _autoEnumerationLocalization<T extends Enumeration>(enumeration: T, name?: LocalizeItem): EnumerationLocalizationEntry<T>;
+export declare function isLocalizeItem(value: any): value is LocalizeItem<any>;
+export {};

package/types/theme/adapters/tailwind-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { Theme } from '../../../theme/theme-service.js';
+export type TailwindPalette = {
+    DEFAULT: string;
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+};
+export declare function generateTailwindColorsFromTheme(theme: Theme, tailwindNamePrefix?: string): Record<string, TailwindPalette>;
+export declare function generateTailwindColorsFromThemeColors(colors: readonly string[], tailwindNamePrefix?: string): Record<string, TailwindPalette>;
+export declare function generateTailwindPalette(color: string): TailwindPalette;