@tstdl/base 0.92.124 → 0.92.125

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

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

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

@@ -1,93 +0,0 @@
-/**
- * @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/password/password-check-result.model.d.ts

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

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

@@ -1,101 +0,0 @@
-/**
- * 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/pool/pool.d.ts

@@ -1,49 +0,0 @@
-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-shutdown.d.ts

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

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

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

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

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

@@ -1,38 +0,0 @@
-import type { CancellationSignal } from '../../../cancellation/index.js';
-import { Lock } from '../../../lock/index.js';
-import { MessageBusProvider } from '../../../message-bus/index.js';
-import type { EnqueueManyItem, EnqueueManyOptions, EnqueueOneOptions, Job, JobTag } from '../../../queue/index.js';
-import { Queue, type QueueConfig } from '../../../queue/index.js';
-import { MongoJobRepository } from './mongo-job.repository.js';
-export declare class MongoQueue<T = unknown> extends Queue<T> {
-    private readonly repository;
-    private readonly lock;
-    private readonly queueKey;
-    private readonly messageBus;
-    readonly processTimeout: number;
-    readonly maxTries: number;
-    constructor(repository: MongoJobRepository<T>, lock: Lock, messageBusProvider: MessageBusProvider, key: string, config?: QueueConfig);
-    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
-    }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<void | Job<T>[]>;
-    has(id: string): Promise<boolean>;
-    countByTag(tag: JobTag): Promise<number>;
-    get(id: string): Promise<Job<T> | undefined>;
-    getByTag(tag: JobTag): Promise<Job<T>[]>;
-    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    cancel(id: string): Promise<void>;
-    cancelMany(ids: string[]): Promise<void>;
-    cancelByTag(tag: JobTag): Promise<void>;
-    cancelByTags(tags: JobTag[]): Promise<void>;
-    dequeue(): Promise<Job<T> | undefined>;
-    dequeueMany(count: number): Promise<Job<T>[]>;
-    acknowledge(job: Job<T>): Promise<void>;
-    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
-}

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

@@ -1,22 +0,0 @@
-import type { CollectionArgument, MongoRepositoryConfig } from '../../../database/mongo/index.js';
-import { resolveArgumentType, type Resolvable } from '../../../injector/interfaces.js';
-import { LockProvider } from '../../../lock/index.js';
-import { MessageBusProvider } from '../../../message-bus/index.js';
-import { QueueProvider, type QueueConfig } from '../../../queue/index.js';
-import type { MongoJob } from './job.js';
-import { MongoJobRepository } from './mongo-job.repository.js';
-import { MongoQueue } from './queue.js';
-export declare class MongoQueueProvider extends QueueProvider implements Resolvable<CollectionArgument<MongoJob>> {
-    private readonly repository;
-    private readonly lockProvider;
-    private readonly messageBusProvider;
-    readonly [resolveArgumentType]: CollectionArgument<MongoJob>;
-    constructor(repository: MongoJobRepository<any>, lockProvider: LockProvider, messageBusProvider: MessageBusProvider);
-    get<T>(name: string, config?: QueueConfig): MongoQueue<T>;
-}
-/**
- * configure mongo queue module
- * @param jobRepositoryConfig repository configuration for jobs
- * @param register whether to register for {@link Queue} and {@link QueueProvider}
- */
-export declare function configureMongoQueue(jobRepositoryConfig: MongoRepositoryConfig<MongoJob>, register?: boolean): void;

package/types/queue/postgres/job.model.d.ts

@@ -1,13 +0,0 @@
-import { EntityWithoutMetadata } from '../../../orm/entity.js';
-import { Integer, Json, Timestamp } from '../../../orm/index.js';
-import type { ObjectLiteral } from '../../../types.js';
-import type { Job } from '../queue.js';
-export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
-    queue: string;
-    tag: string | null;
-    priority: Integer;
-    enqueueTimestamp: Timestamp;
-    tries: Integer;
-    lastDequeueTimestamp: Timestamp | null;
-    data: Json<T>;
-}

package/types/queue/postgres/module.d.ts

@@ -1,9 +0,0 @@
-import { type DatabaseConfig } from '../../../orm/server/index.js';
-export declare class PostgresQueueModuleConfig {
-    database?: DatabaseConfig;
-}
-/**
- * configure mail module
- */
-export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
-export declare function migratePostgresQueueSchema(): Promise<void>;

package/types/queue/postgres/queue.d.ts

@@ -1,31 +0,0 @@
-import { CancellationSignal } from '../../../cancellation/index.js';
-import type { ObjectLiteral } from '../../../types.js';
-import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Job, type JobTag } from '../queue.js';
-export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
-    #private;
-    readonly processTimeout: number;
-    readonly maxTries: number;
-    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
-    }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
-    has(id: string): Promise<boolean>;
-    countByTag(tag: JobTag): Promise<number>;
-    get(id: string): Promise<Job<T> | undefined>;
-    getByTag(tag: JobTag): Promise<Job<T>[]>;
-    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    cancel(id: string): Promise<void>;
-    cancelMany(ids: string[]): Promise<void>;
-    cancelByTag(tag: JobTag): Promise<void>;
-    cancelByTags(tags: JobTag[]): Promise<void>;
-    dequeue(): Promise<Job<T> | undefined>;
-    dequeueMany(count: number): Promise<Job<T>[]>;
-    acknowledge(job: Job<T>): Promise<void>;
-    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
-}

package/types/queue/postgres/queue.provider.d.ts

@@ -1,7 +0,0 @@
-import { QueueProvider, type QueueConfig } from '../../../queue/index.js';
-import type { ObjectLiteral } from '../../../types.js';
-import { PostgresQueue } from './queue.js';
-export declare class PostgresQueueProvider extends QueueProvider {
-    #private;
-    get<T extends ObjectLiteral>(name: string, config?: QueueConfig): PostgresQueue<T>;
-}

package/types/queue/postgres/schemas.d.ts

@@ -1,3 +0,0 @@
-import { PostgresJob } from './job.model.js';
-export declare const queueSchema: import("../../../orm/server/database-schema.js").DatabaseSchema<"queue">;
-export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/types/queue/provider.d.ts

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