@tstdl/base 0.92.123 → 0.92.124

package/types/orm/server/transaction.d.ts

@@ -0,0 +1,29 @@
+import type { PgTransaction as DrizzlePgTransaction, PgQueryResultHKT, PgTransactionConfig } from 'drizzle-orm/pg-core';
+import { DeferredPromise } from '../../../promise/deferred-promise.js';
+import type { Record } from '../../../types.js';
+import type { Database } from './database.js';
+export type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
+export type TransactionConfig = PgTransactionConfig;
+export declare abstract class Transaction {
+    #private;
+    readonly afterCommit$: import("rxjs").Observable<void>;
+    manualCommit: boolean;
+    withManualCommit(): void;
+    /**
+     * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
+     */
+    use<T>(handler: () => Promise<T>): Promise<T>;
+    commit(): Promise<void>;
+    rollback(): void;
+    protected abstract _commit(): Promise<void>;
+    protected abstract _rollback(): void;
+}
+export declare class DrizzleTransaction extends Transaction {
+    readonly pgTransaction: PgTransaction;
+    readonly deferPromise: DeferredPromise<void>;
+    readonly pgTransactionPromise: Promise<void>;
+    constructor(pgTransaction: PgTransaction, pgTransactionPromise: Promise<void>);
+    static create(session: Database | PgTransaction, config?: TransactionConfig): Promise<DrizzleTransaction>;
+    protected _commit(): Promise<void>;
+    protected _rollback(): void;
+}

package/types/orm/server/transactional.d.ts

@@ -0,0 +1,75 @@
+import { Database } from './database.js';
+import { type PgTransaction, type Transaction, type TransactionConfig } from './transaction.js';
+export type TransactionInitOptions = TransactionConfig & {
+    /**
+     * Indicates that an existing transaction should be used if available instead of creating a new one.
+     * @default true
+     */
+    useExisting?: boolean;
+};
+export type TransactionHandler<R> = (transaction: Transaction) => Promise<R>;
+type TransactionalContext<ContextData = unknown> = {
+    session: Database | PgTransaction;
+    cache: WeakMap<Database | PgTransaction, any>;
+    data: ContextData;
+};
+declare const getCurrentTransactionalContext: {
+    (required: true, debugFn: import("../../../types.js").Function): TransactionalContext<unknown>;
+    (required?: false, debugFn?: import("../../../types.js").Function): TransactionalContext<unknown> | null;
+    (required: boolean, debugFn: import("../../../types.js").Function): TransactionalContext<unknown> | null;
+}, runInTransactionalContext: <ReturnT>(context: TransactionalContext<unknown>, fn: () => ReturnT) => ReturnT, isInTransactionalContext: () => boolean;
+export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
+export declare abstract class Transactional<ContextData = unknown> {
+    #private;
+    readonly session: PgTransaction | Database;
+    readonly isInTransaction: boolean;
+    constructor();
+    /**
+     * Starts a new database transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the new Transaction instance.
+     */
+    startTransaction(config?: TransactionInitOptions): Promise<Transaction>;
+    /**
+     * Returns a new instance of the repository bound to the provided session.
+     * Useful for performing multiple operations within a single database session.
+     * @param session The session to bind to.
+     * @returns A new repository instance bound to the session.
+     */
+    withSession(session: Database | PgTransaction): this;
+    /**
+       * Returns a new instance of the repository bound to the provided transaction, if a transaction is provided.
+       * Otherwise, returns the current instance.
+       * @param transaction The transaction to bind to (optional).
+       * @returns A repository instance bound to the transaction or the current instance.
+       */
+    withOptionalTransaction(transaction: Transaction | undefined): this;
+    /**
+     * Returns a new instance of the repository bound to the provided transaction.
+     * Useful for performing multiple operations within a single database transaction.
+     * @param transaction The transaction to bind to.
+     * @returns A new repository instance bound to the transaction.
+     */
+    withTransaction(transaction: Transaction): this;
+    /**
+     * Executes a handler function within the provided transaction. If no transaction is provided,
+     * it starts a new transaction, executes the handler, and commits or rolls back based on the outcome.
+     * @template R The return type of the handler.
+     * @param existingTransaction The transaction to use (optional). Creates a new one otherwise.
+     * @param handler The function to execute within the transaction.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    useTransaction<R>(existingTransaction: Transaction | undefined, handler: TransactionHandler<R>): Promise<R>;
+    /**
+     * Starts a new transaction, executes the provided handler function within it,
+     * and automatically commits the transaction if the handler succeeds or rolls it back if it throws an error.
+     * @template R The return type of the handler.
+     * @param handler The function to execute within the transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    transaction<R>(handler: TransactionHandler<R>, config?: TransactionInitOptions): Promise<R>;
+    protected getTransactionalContextData(): ContextData;
+}
+export declare function tryGetTransactionalContextData<T>(_instance?: Transactional<T>): T | undefined;
+export declare function getTransactionalContextData<T>(_instance?: Transactional<T>): T;

package/types/orm/server/types.d.ts

@@ -0,0 +1,47 @@
+import type { BuildColumns, NotNull } from 'drizzle-orm';
+import type { PgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { Record } from '../../../schema/index.js';
+import type { UnionToIntersection } from '../../../types.js';
+import type { Tagged } from '../../../types/index.js';
+import type { OrmColumnReflectionData } from '../decorators.js';
+import type { EntityType } from '../entity.js';
+import type { ColumnBuilder, EmbeddedConfigTag } from '../types.js';
+export type BuildTypeOptions = {
+    skipPrimaryKey?: boolean;
+};
+export type ColumnDefinition = {
+    name: string;
+    objectPath: JsonPath;
+    reflectionData: OrmColumnReflectionData | undefined;
+    buildType: (options: BuildTypeOptions) => PgColumnBuilder<any, any, any, any>;
+    dereferenceObjectPath: (obj: Record) => any;
+    toDatabase: (value: unknown, context: TransformContext) => any;
+    fromDatabase: (value: unknown, context: TransformContext) => any;
+};
+export type ColumnDefinitionsMap = Map<string, ColumnDefinition>;
+export type TransformContext = {
+    encryptionKey?: CryptoKey;
+};
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<Exclude<T, null>, Name> : NotNull<ColumnBuilder<T, Name>>;
+export type ColumnPrefix<T> = T extends Tagged<unknown, EmbeddedConfigTag, {
+    prefix: infer Prefix;
+}> ? Prefix extends string ? Prefix : '' : '';
+export type PgTableFromType<T extends EntityType = EntityType, S extends string = string, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+    name: TableName;
+    schema: S;
+    columns: BuildColumns<TableName, {
+        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
+    } & UnionToIntersection<{
+        [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
+    }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;
+    dialect: 'pg';
+}>;
+export type EmbeddedProperties<T> = ConditionalPick<T, Tagged<unknown, EmbeddedConfigTag, {
+    prefix: any;
+}>>;
+export type EmbeddedColumns<T, Prefix extends string> = {
+    [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
+};
+export {};

package/types/orm/sqls.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @module
+ * Provides utility SQL functions and constants for use with Drizzle ORM,
+ * simplifying common SQL operations like generating UUIDs, working with intervals,
+ * and aggregating data.
+ */
+import { type Column, type SQL } from 'drizzle-orm';
+import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
+import type { Uuid } from './types.js';
+/** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
+export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
+/** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
+export declare const RANDOM_UUID: SQL<Uuid>;
+/** Represents valid units for PostgreSQL interval values. */
+export type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
+/**
+ * Creates a Drizzle SQL interval expression.
+ * @param value - The numeric value of the interval.
+ * @param unit - The unit of the interval (e.g., 'day', 'hour').
+ * @returns A Drizzle SQL object representing the interval.
+ */
+export declare function interval(value: number, unit: IntervalUnit): SQL;
+/**
+ * Creates a Drizzle SQL `array_agg` aggregate function call.
+ * Aggregates values from a column into a PostgreSQL array.
+ * @template T - The Drizzle column type.
+ * @param column - The column to aggregate.
+ * @returns A Drizzle SQL object representing the aggregated array.
+ */
+export declare function arrayAgg<T extends Column>(column: T): SQL<SelectResultField<T>[]>;
+/**
+ * Creates a Drizzle SQL `json_agg` aggregate function call.
+ * Aggregates rows or column values into a JSON array.
+ * @template T - The Drizzle table or column type.
+ * @param tableOrColumn - The table or column to aggregate into JSON.
+ * @returns A Drizzle SQL object representing the JSON aggregated array.
+ */
+export declare function jsonAgg<T extends TableLike>(tableOrColumn: T): SQL<SelectResultField<GetSelectTableSelection<T>>[]>;
+export declare namespace jsonAgg {
+    var withNull: <T extends TableLike>(tableOrColumn: T) => SQL<(SelectResultField<GetSelectTableSelection<T>> | null)[]>;
+}
+/**
+ * Creates a Drizzle SQL `coalesce` function call.
+ * Returns the first non-null value from the provided list of columns or SQL expressions.
+ * @template T - An array type of Drizzle Columns or SQL expressions.
+ * @param columns - The columns or SQL expressions to check.
+ * @returns A Drizzle SQL object representing the coalesced value.
+ */
+export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
+/**
+ * Creates a Drizzle SQL `to_jsonb` function call.
+ * Converts the input column or SQL expression to a JSONB value.
+ * @template T - The Drizzle column or SQL expression type.
+ * @param column - The column or SQL expression to convert.
+ * @returns A Drizzle SQL object representing the value as JSONB.
+ */
+export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
+/**
+ * Creates a Drizzle SQL `num_nulls` function call.
+ * Counts the number of null arguments.
+ * @param columns - The columns to check for nulls.
+ * @returns A Drizzle SQL object representing the count of nulls.
+ */
+export declare function numNulls(...columns: Column[]): SQL<number>;
+/**
+ * Creates a Drizzle SQL `num_nonnulls` function call.
+ * Counts the number of non-null arguments.
+ * @param columns - The columns to check for non-nulls.
+ * @returns A Drizzle SQL object representing the count of non-nulls.
+ */
+export declare function numNonNulls(...columns: Column[]): SQL<number>;

package/types/orm/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @module
+ * Defines core ORM types, including tagged types for representing database column types
+ * (like Uuid, Timestamp, Json, etc.) and helper types for working with Drizzle ORM features
+ * like primary keys and default values. It also re-exports common decorators and schemas.
+ */
+import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
+import type { boolean, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
+import { Array, Integer } from '../../schema/index.js';
+import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../../types.js';
+import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../../types/index.js';
+import type { bytea, numericDate, timestamp } from './data-types/index.js';
+import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Table, Unique } from './decorators.js';
+import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
+/** Tag identifier for column type information. */
+export type ColumnTypeTag = 'column';
+/** Tag identifier for embedded type configuration. */
+export type EmbeddedConfigTag = 'embedded';
+/**
+ * Helper type to tag a column type as being a primary key.
+ * It wraps the original type `T` and associates Drizzle's `IsPrimaryKey` marker
+ * with the underlying Drizzle column builder type stored in the tag metadata.
+ * @template T - The original column type (e.g., Uuid, Integer).
+ */
+export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
+/**
+ * Helper type to tag a column type as having a default value.
+ * It wraps the original type `T` and associates Drizzle's `HasDefault` marker
+ * with the underlying Drizzle column builder type stored in the tag metadata.
+ * @template T - The original column type (e.g., Uuid, Timestamp).
+ */
+export type HasDefault<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleHasDefault<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleHasDefault<ColumnBuilder<T>>>;
+type EnumColumn<T extends string | number, ColumnName extends string = ''> = PgEnumColumnBuilderInitial<ColumnName, UnionToTuple<`${T}`> extends [string, ...string[]] ? UnionToTuple<`${T}`> : ['NO_VALUES_PROVIDED']>;
+type TextTuple<T extends string> = UnionToTuple<`${T}`> extends [string, ...string[]] ? UnionToTuple<`${T}`> : [string];
+type HandledColumnName<T extends string = never> = [T] extends [never] ? '' : T;
+/**
+ * Utility type to infer the Drizzle column builder type based on a TypeScript type `T`.
+ * Handles primitive types (string, number, boolean), arrays, enums, Uint8Array,
+ * and existing tagged column types.
+ * @template T - The TypeScript type to map to a column builder.
+ * @template ColumnName - Optional column name for context.
+ */
+export type ColumnBuilder<T, ColumnName extends string = never> = HasTag<T> extends true ? T extends Tagged<unknown, ColumnTypeTag, any> ? GetTagMetadata<T, ColumnTypeTag> : never : T extends string ? ReturnType<typeof text<HandledColumnName<ColumnName>, string, TextTuple<T>>> : T extends number ? ReturnType<typeof doublePrecision<HandledColumnName<ColumnName>>> : T extends boolean ? ReturnType<typeof boolean<HandledColumnName<ColumnName>>> : T extends Uint8Array ? ReturnType<typeof bytea<HandledColumnName<ColumnName>>> : T extends EnumerationObject ? EnumColumn<EnumerationValue<T>, HandledColumnName<ColumnName>> : T extends (infer U)[] ? ReturnType<ColumnBuilder<U, HandledColumnName<ColumnName>>['array']> : never;
+/**
+ * Tagged type representing an embedded class configuration.
+ * Stores the embedded type `T` and an optional column name prefix `P`.
+ * @template T - The constructor of the class being embedded.
+ * @template P - An optional prefix for the column names generated from the embedded class properties.
+ */
+export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T, EmbeddedConfigTag, {
+    prefix: P;
+}>;
+/**
+ * Tagged type representing a PostgreSQL array column.
+ * Wraps an existing tagged column type `T` and derives the Drizzle array column builder.
+ * @template T - The tagged type of the array elements.
+ */
+export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
+/**
+ * Tagged type representing a JSONB column.
+ * Stores the TypeScript type `T` that the JSONB data represents.
+ * @template T - The TypeScript type of the data stored in the JSONB column.
+ */
+export type Json<T> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
+/**
+ * Tagged type representing a PostgreSQL enum column.
+ * Derives the enum values and the Drizzle enum column builder from the provided enum object `T`.
+ * @template T - The enumeration object type.
+ */
+export type Enum<T extends string | number> = Tagged<T, ColumnTypeTag, EnumColumn<T>>;
+/** Tagged type representing a `text` column. */
+export type Text<T extends string = string> = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, TextTuple<T>>>>;
+/** Tagged type representing a `uuid` column. Stores the UUID as a string. */
+export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
+/** Tagged type representing an `integer` column. */
+export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
+/** Tagged type representing a `double precision` column. */
+export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
+/** Tagged type representing a `boolean` column. */
+export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
+/** Tagged type representing a custom `numericDate` column (stores date as number YYYYMMDD). */
+export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof numericDate>>;
+/** Tagged type representing a `timestamp` column (stores timestamp as number - milliseconds since epoch). */
+export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
+/** Tagged type representing a `bytea` (byte array) column. */
+export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
+/**
+ * Tagged type representing an encrypted column.
+ * Stores the original TypeScript type `T`, but the underlying database type is `bytea`.
+ * @template T - The original (unencrypted) type of the data.
+ */
+export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;
+export { Array, Check, Column, Embedded, Encrypted, Index, Integer, Json, NumericDate, PrimaryKey, References, Table, Timestamp, Unique, Uuid };

package/types/orm/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module
+ * Provides utility functions for working with ORM entities.
+ */
+import type { Entity, EntityWithoutMetadata } from './entity.js';
+/**
+ * Converts an array of entities into a Map keyed by entity ID.
+ * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
+ * @param entities - An array of entities.
+ * @returns A Map where keys are entity IDs and values are the corresponding entities.
+ */
+export declare function getEntityMap<T extends Entity | EntityWithoutMetadata>(entities: T[]): Map<string, T>;
+/**
+ * Extracts the IDs from an array of entities.
+ * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
+ * @param entities - An array of entities.
+ * @returns An array containing the IDs of the entities.
+ */
+export declare function getEntityIds(entities: (Entity | EntityWithoutMetadata)[]): string[];

package/types/password/password-check-result.model.d.ts

@@ -0,0 +1,19 @@
+import { type EnumType } from '../../enumeration/enumeration.js';
+export declare const PasswordStrength: {
+    readonly VeryWeak: 0;
+    readonly Weak: 1;
+    readonly Medium: 2;
+    readonly Strong: 3;
+    readonly VeryStrong: 4;
+};
+export type PasswordStrength = EnumType<typeof PasswordStrength>;
+export declare class PasswordCheckResult {
+    strength: PasswordStrength;
+    /**
+     * Count of how many times it appears in the data set from https://haveibeenpwned.com/
+     * Undefined if disabled in options or error occured (either timeout or api error)
+     */
+    pwned?: number;
+    warnings: string[];
+    suggestions: string[];
+}

package/types/password/password-check.localization.d.ts

@@ -0,0 +1,20 @@
+import type { Localization, LocalizeItem } from '../../text/localization.service.js';
+import type zxcvbnTranslationKeys from '@zxcvbn-ts/core/dist/data/translationKeys.js';
+export type PasswordCheckLocalization = Localization<{
+    tstdl: {
+        passwordCheck: {
+            warnings: Record<keyof typeof zxcvbnTranslationKeys['default']['warnings'], LocalizeItem>;
+            suggestions: Record<keyof typeof zxcvbnTranslationKeys['default']['suggestions'], LocalizeItem>;
+        };
+    };
+}>;
+export declare const passwordCheckLocalizationKeys: import("../../text/localization.service.js").ProxyLocalizationKeys<{
+    tstdl: {
+        passwordCheck: {
+            warnings: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["warnings"], LocalizeItem>;
+            suggestions: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["suggestions"], LocalizeItem>;
+        };
+    };
+}>;
+export declare const germanPasswordCheckLocalization: PasswordCheckLocalization;
+export declare const englishPasswordCheckLocalization: PasswordCheckLocalization;

package/types/pdf/pdf.service.d.ts

@@ -0,0 +1,101 @@
+/**
+ * PDF generation
+ *
+ * @module PDF
+ */
+import { BrowserContextController } from '../../browser/browser-context-controller.js';
+import type { BrowserControllerArgument } from '../../browser/browser-controller.js';
+import { PdfRenderOptions } from '../../browser/pdf-options.js';
+import type { Resolvable } from '../../injector/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import { LogLevel } from '../../logger/level.js';
+import type { TemplateField } from '../../templates/index.js';
+import { Template } from '../../templates/index.js';
+export declare class PdfServiceRenderOptions extends PdfRenderOptions {
+    browserContext?: BrowserContextController;
+    locale?: string;
+    /**
+     * @default true
+     */
+    waitForNetworkIdle?: boolean;
+    /**
+     * Delay pdf creation to ensure content has finished rendering
+     * @default 50
+     */
+    delay?: number;
+    /**
+     * @default false
+     */
+    log?: boolean | LogLevel;
+}
+export type PdfTemplateOptions = PdfRenderOptions;
+export declare class PdfTemplate<Context extends object = any> extends Template<{
+    header: false;
+    body: true;
+    footer: false;
+}, PdfRenderOptions, Context> {
+    options?: PdfTemplateOptions;
+}
+export type PdfServiceOptions = {
+    locale?: string;
+};
+export type PdfServiceArgument = PdfServiceOptions & {
+    browserControllerArgument: BrowserControllerArgument;
+};
+export declare class PdfService implements Resolvable<PdfServiceArgument> {
+    private readonly templateService;
+    private readonly browserController;
+    private readonly logger;
+    private readonly defaultLocale;
+    readonly [resolveArgumentType]: PdfServiceArgument;
+    /**
+     * Renders HTML to pdf stream
+     * @param html html to render
+     * @param options render options
+     * @returns pdf stream
+     */
+    renderHtmlStream(html: string, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders HTML to pdf
+     * @param html html to render
+     * @param options render options
+     * @returns pdf bytes
+     */
+    renderHtml(html: string, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    /**
+     * Renders an url to pdf stream
+     * @param url url to load and render
+     * @param options render options
+     * @returns pdf stream
+     */
+    renderUrlStream(url: string, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders an url to pdf
+     * @param url url to load and render
+     * @param options render options
+     * @returns pdf bytes
+     */
+    renderUrl(url: string, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    /**
+     * Renders a template to pdf
+     * @param key template key
+     * @param templateContext context for template rendering
+     * @param options additional options, overwrites options specified in template
+     * @returns pdf bytes
+     */
+    renderTemplateStream<Context extends object>(keyOrTemplate: string | PdfTemplate<Context>, templateContext?: Context, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders a template to pdf
+     * @param key template key
+     * @param templateContext context for template rendering
+     * @param options additional options, overwrites options specified in template
+     * @returns pdf bytes
+     */
+    renderTemplate(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    private renderStream;
+}
+export declare function pdfTemplate(name: string, fields: {
+    body: TemplateField;
+    header?: TemplateField;
+    footer?: TemplateField;
+}, options?: PdfTemplateOptions): PdfTemplate;

package/types/pdf/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function getPdfPageCount(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<number>;
+export declare function mergePdfs(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<Uint8Array>;
+export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<ReadableStream<Uint8Array>>;
+/**
+ * Convert a PDF page to an image.
+ * @param file The PDF file to convert.
+ * @param page The page number to convert.
+ * @param size The size of the output image.
+ * @param format The format of the output image.
+ * @returns The converted image as a byte array.
+ */
+export declare function pdfToImage(file: string | Uint8Array | ReadableStream<Uint8Array>, page: number, size: number, format: 'png' | 'jpeg' | 'tiff' | 'ps' | 'eps' | 'pdf' | 'svg'): Promise<Uint8Array>;

package/types/pool/pool.d.ts

@@ -0,0 +1,49 @@
+import type { AsyncDisposable } from '../../disposable/disposable.js';
+import { disposeAsync } from '../../disposable/disposable.js';
+import type { Logger } from '../../logger/index.js';
+export type PoolOptions = {
+    /**
+     * Maximum number of instances
+     * @default number of cpu cores
+     */
+    size?: number;
+    /**
+     * Dipose used instance on error instead of reusing it.
+     * @default false
+     */
+    disposeOnError?: boolean;
+};
+export type PoolUseOptions = {
+    /**
+     * Dipose used instance on error instead of reusing it. Overwrites pool instance option
+     * @default false
+     */
+    disposeOnError?: boolean;
+};
+export type PoolInstanceFactory<T> = () => T | Promise<T>;
+export type PoolInstanceDisposer<T> = (instance: T) => any | Promise<any>;
+export declare class Pool<T extends object> implements AsyncDisposable {
+    private readonly size;
+    private readonly disposeOnError;
+    private readonly freeInstances;
+    private readonly usedInstances;
+    private readonly factory;
+    private readonly disposer;
+    private readonly logger;
+    private placeholderInstances;
+    private disposed;
+    get length(): number;
+    constructor(factory: PoolInstanceFactory<T>, disposer: PoolInstanceDisposer<T>, logger: Logger, options?: PoolOptions);
+    owns(instance: T): boolean;
+    get(): Promise<T>;
+    release(instance: T): Promise<void>;
+    /**
+     * Get an instance from the pool and use it
+     * @param handler consumer of instance
+     * @returns instance
+     */
+    use<R>(handler: (instance: T) => R | Promise<R>, options?: PoolUseOptions): Promise<R>;
+    disposeInstance(instance: T): Promise<void>;
+    dispose(): Promise<void>;
+    [disposeAsync](): Promise<void>;
+}

package/types/process/spawn.d.ts

@@ -0,0 +1,22 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+type WaitOptions = {
+    throwOnNonZeroExitCode?: boolean;
+};
+type ProcessResult = {
+    code: number | null;
+    signal: string | null;
+};
+export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
+    process: ChildProcessWithoutNullStreams;
+    stderr: ReadableStream<Uint8Array>;
+    write(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): Promise<void>;
+    autoWrite(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): void;
+    readOutputBytes(): Promise<Uint8Array>;
+    readOutput(): Promise<string>;
+    readErrorBytes(): Promise<Uint8Array>;
+    readError(): Promise<string>;
+    handleNonZeroExitCode(): void;
+    wait(options?: WaitOptions): Promise<ProcessResult>;
+};
+export declare function spawnCommand(command: string, args?: string[]): Promise<SpawnCommandResult>;
+export {};

package/types/process-shutdown.d.ts

@@ -0,0 +1,9 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import { CancellationToken } from '../cancellation/index.js';
+import type { Logger } from '../logger/index.js';
+export declare function getShutdownToken(): CancellationToken;
+export declare function getShutdownSignal(): CancellationSignal;
+export declare function setProcessShutdownLogger(shutdownLogger: Logger): void;
+export declare function requestShutdown(exitCode?: number): void;
+export declare function forceShutdown(exitCode?: number): void;
+export declare function initializeSignals(): void;

package/types/promise/cancelable-promise.d.ts

@@ -0,0 +1,15 @@
+import { type CancellationSignal } from '../../cancellation/token.js';
+import { CustomPromise } from './custom-promise.js';
+export type CancelablePromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, cancellationSignal: CancellationSignal) => void;
+export type CancelablePromiseResult<T, R> = {
+    canceled: true;
+    reason: R;
+} | {
+    canceled: false;
+    value: T;
+};
+export declare class CancelablePromise<T, R = void> extends CustomPromise<CancelablePromiseResult<T, R>> {
+    #private;
+    constructor(executor: CancelablePromiseExecutor<T>);
+    cancel(reason: R): void;
+}

package/types/queue/mongo/job.d.ts

@@ -0,0 +1,12 @@
+import type { Entity, NewEntity } from '../../../database/index.js';
+import type { Job } from '../../../queue/index.js';
+import type { TypedOmit } from '../../../types.js';
+export type MongoJob<T = unknown> = Entity & TypedOmit<Job<T>, 'id'> & {
+    queue: string;
+    jobId: string;
+    enqueueTimestamp: number;
+    tries: number;
+    lastDequeueTimestamp: number;
+    batch: null | string;
+};
+export type NewMongoJob<T> = NewEntity<MongoJob<T>>;

package/types/queue/mongo/mongo-job.repository.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionArgument } from '../../../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
+import type { Resolvable } from '../../../injector/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import { Logger } from '../../../logger/index.js';
+import { UniqueTagStrategy } from '../../../queue/index.js';
+import type { MongoJob, NewMongoJob } from './job.js';
+export declare class MongoJobRepository<T> extends MongoEntityRepository<MongoJob<T>> implements Resolvable<CollectionArgument<MongoJob<T>>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoJob<T>>;
+    constructor(collection: Collection<MongoJob<T>>, logger: Logger);
+    insertWithUniqueTagStrategy(newJob: NewMongoJob<T>, uniqueTagStrategy: UniqueTagStrategy): Promise<MongoJob<T>>;
+    bulkInsertWithUniqueTagStrategy(newJobs: NewMongoJob<T>[], uniqueTagStrategy: UniqueTagStrategy): Promise<void>;
+}