@tstdl/base 0.92.123 → 0.92.124

package/orm/server/transaction.d.ts

@@ -1,29 +0,0 @@
-import { DeferredPromise } from '../../promise/deferred-promise.js';
-import type { PgTransaction as DrizzlePgTransaction, PgTransactionConfig } from 'drizzle-orm/pg-core';
-import type { Database } from './database.js';
-type PgTransaction = DrizzlePgTransaction<any, any, any>;
-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 transaction: PgTransaction;
-    readonly deferPromise: DeferredPromise<void>;
-    readonly pgTransactionPromise: Promise<void>;
-    constructor(transaction: PgTransaction, pgTransactionPromise: Promise<void>);
-    static create(session: Database | PgTransaction, config?: TransactionConfig): Promise<DrizzleTransaction>;
-    protected _commit(): Promise<void>;
-    protected _rollback(): void;
-}
-export {};

package/orm/server/types.d.ts

@@ -1,46 +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 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/orm/sqls.d.ts

@@ -1,16 +0,0 @@
-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';
-export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
-export declare const RANDOM_UUID: SQL<Uuid>;
-export type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
-export declare function interval(value: number, unit: IntervalUnit): SQL;
-export declare function arrayAgg<T extends Column>(column: T): SQL<SelectResultField<T>[]>;
-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)[]>;
-}
-export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
-export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
-export declare function numNulls(...columns: Column[]): SQL<number>;
-export declare function numNonNulls(...columns: Column[]): SQL<number>;

package/orm/types.d.ts

@@ -1,30 +0,0 @@
-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';
-export type ColumnTypeTag = 'column';
-export type EmbeddedConfigTag = 'embedded';
-export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
-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 EnumerationObject, ColumnName extends string = ''> = PgEnumColumnBuilderInitial<ColumnName, UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : ['NO_VALUES_PROVIDED']>;
-export type ColumnBuilder<T, ColumnName extends string = never> = HasTag<T> extends true ? T extends Tagged<T, ColumnTypeTag, any> ? GetTagMetadata<T, ColumnTypeTag> : never : T extends string ? string extends ColumnName ? ReturnType<typeof text<ColumnName, string, [string, ...string[]]>> : ReturnType<typeof text<string, [string, ...string[]]>> : T extends number ? string extends ColumnName ? ReturnType<typeof doublePrecision<ColumnName>> : ReturnType<typeof doublePrecision> : T extends boolean ? string extends ColumnName ? ReturnType<typeof boolean<ColumnName>> : ReturnType<typeof boolean> : T extends Uint8Array ? string extends ColumnName ? ReturnType<typeof bytea<ColumnName>> : ReturnType<typeof bytea> : T extends EnumerationObject ? string extends ColumnName ? EnumColumn<T, ColumnName> : EnumColumn<T> : T extends (infer U)[] ? string extends ColumnName ? ReturnType<ColumnBuilder<U, ColumnName>['array']> : ReturnType<ColumnBuilder<U>['array']> : never;
-export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T, EmbeddedConfigTag, {
-    prefix: P;
-}>;
-export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
-export type Json<T> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
-export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, ColumnTypeTag, EnumColumn<T>>;
-export type Text = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, [string, ...string[]]>>>;
-export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
-export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
-export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
-export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
-export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof numericDate>>;
-export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
-export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
-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/orm/utils.d.ts

@@ -1,3 +0,0 @@
-import type { Entity } from './entity.js';
-export declare function getEntityMap<T extends Entity>(entities: T[]): Map<string, T>;
-export declare function getEntityIds<T extends Entity>(entities: T[]): string[];

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

@@ -1,17 +0,0 @@
-export declare enum PasswordStrength {
-    VeryWeak = 0,
-    Weak = 1,
-    Medium = 2,
-    Strong = 3,
-    VeryStrong = 4
-}
-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/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/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/pdf/utils.d.ts

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

package/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/process/spawn.d.ts

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

package/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/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/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/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/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/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/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/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/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/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/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/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>;
-}

package/queue/queue.d.ts

@@ -1,89 +0,0 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import type { Logger } from '../logger/logger.js';
-import { QueueEnqueueBatch } from './enqueue-batch.js';
-export type ProcessWorker<T> = (job: Job<T>) => void | Promise<void>;
-export type ProcessBatchWorker<T> = (jobs: Job<T>[]) => void | Promise<void>;
-export type JobTag = string | null;
-export type Job<T> = {
-    id: string;
-    /**
-     * The lower the number, the higher the priority.
-     * @default 1000
-     */
-    priority: number;
-    tag: JobTag;
-    data: T;
-    enqueueTimestamp: number;
-    lastDequeueTimestamp: number | null;
-    tries: number;
-};
-export declare const defaultJobPriority = 1000;
-export declare enum UniqueTagStrategy {
-    KeepOld = 0,
-    TakeNew = 1
-}
-export type EnqueueOptions = {
-    tag?: JobTag;
-    priority?: number;
-};
-export type EnqueueOneOptions = {
-    tag?: JobTag;
-    uniqueTag?: UniqueTagStrategy;
-    priority?: number;
-};
-export type EnqueueManyItem<T> = EnqueueOptions & {
-    data: T;
-};
-export type EnqueueManyOptions = {
-    uniqueTag?: UniqueTagStrategy;
-    returnJobs?: boolean;
-};
-export type QueueConfig = {
-    processTimeout?: number;
-    maxTries?: number;
-};
-export type QueueArgument = string | (QueueConfig & {
-    name: string;
-});
-export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
-    readonly [resolveArgumentType]: QueueArgument;
-    abstract readonly processTimeout: number;
-    abstract readonly maxTries: number;
-    batch(): QueueEnqueueBatch<T>;
-    abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
-    }): Promise<void>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
-    abstract has(id: string): Promise<boolean>;
-    abstract countByTag(tag: JobTag): Promise<number>;
-    abstract get(id: string): Promise<Job<T> | undefined>;
-    abstract getByTag(tag: JobTag): Promise<Job<T>[]>;
-    abstract getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    abstract cancel(id: string): Promise<void>;
-    abstract cancelMany(ids: string[]): Promise<void>;
-    abstract cancelByTag(tag: JobTag): Promise<void>;
-    abstract cancelByTags(tags: JobTag[]): Promise<void>;
-    abstract dequeue(): Promise<Job<T> | undefined>;
-    abstract dequeueMany(count: number): Promise<Job<T>[]>;
-    abstract acknowledge(job: Job<T>): Promise<void>;
-    abstract acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
-    process({ concurrency, cancellationSignal }: {
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-    }, handler: ProcessWorker<T>, logger: Logger): void;
-    processBatch({ batchSize, concurrency, cancellationSignal }: {
-        batchSize?: number;
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-    }, handler: ProcessBatchWorker<T>, logger: Logger): void;
-    private processWorker;
-    private processBatchWorker;
-}