@cequrebackends/cequre-ts 0.11.4

package/dist/shared/main/runtime.d.ts

@@ -0,0 +1,195 @@
+import type { CequreAST, StorageProvider, CacheStore, CequrePlugin } from "../core/types";
+import type { CequreAdapter, WhereClause } from "../core/adapter";
+import { type DurableStreamStore } from "../core/stream";
+import type { AccessRules, AuthUser, CequreRequestContext } from "./access";
+import type { Hooks } from "./hooks";
+import { CequreRouter } from "./router";
+import { type CequreMonitoringAPI } from "@cequrebackends/cequre-plugin-monitoring";
+import { RateLimiter } from "@cequrebackends/cequre-plugin-security";
+import { type CequreMailer } from "../core/email";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { JWTAuthenticator } from "@cequrebackends/cequre-plugin-security";
+import { type CequreAuditEvent } from "@cequrebackends/cequre-plugin-security";
+/**
+ * AsyncLocalStorage for propagating the request ID from the router
+ * to the runtime's audit calls without threading it through every
+ * method signature. Set by the router in `runRequest`, read by
+ * `audit()` and the CRUD wrappers.
+ */
+export declare const requestContextStorage: AsyncLocalStorage<string | undefined>;
+export interface CequreConfig {
+    adapter: CequreAdapter;
+    storageProvider?: StorageProvider;
+    cache?: CacheStore;
+    plugins?: CequrePlugin[];
+    email?: import("../core/types").EmailConfig;
+    streamStore?: DurableStreamStore;
+    /** KV store config for rate limiter. Defaults to memory (single-instance). Use redis for multi-instance. */
+    kv?: {
+        driver: "memory" | "sqlite" | "redis";
+        redis?: {
+            host?: string;
+            port?: number;
+            url?: string;
+        };
+        sqlite?: {
+            path?: string;
+        };
+    };
+    serverProvider?: import("../core/types").ServerProvider;
+    cronProvider?: import("../core/types").CronProvider;
+    realtimeProvider?: import("../core/types").RealtimeProvider;
+}
+import { CequreDurableQueue } from "../utils/durable-queue";
+export declare class CequreRuntime<TCollections extends Record<string, any> = Record<string, any>> {
+    schema: CequreAST;
+    adapter: CequreAdapter;
+    router: CequreRouter<TCollections>;
+    rateLimiter: RateLimiter;
+    storage: StorageProvider;
+    cache: CacheStore;
+    queue: CequreDurableQueue;
+    plugins: CequrePlugin[];
+    mailer?: CequreMailer;
+    streamStore: DurableStreamStore;
+    serverProvider?: import("../core/types").ServerProvider;
+    cronManager: import("../core/types").CronProvider;
+    realtimeProvider?: import("../core/types").RealtimeProvider;
+    monitoring?: CequreMonitoringAPI;
+    auditEnabled: boolean;
+    private auditKeyPromise?;
+    private auditRetentionTimer?;
+    private encryptionKeyPromise?;
+    authEngine?: JWTAuthenticator;
+    readonly isTransaction: boolean;
+    private inFlightRequests;
+    private shuttingDown;
+    private idempotencyKV?;
+    lockoutKV: import("../utils/kv").CequreKV;
+    hooksMap: Map<string, Hooks<any, any, AuthUser>>;
+    private _access;
+    private _cacheKeyRegistry;
+    setAuthEngine(engine: JWTAuthenticator): void;
+    enableAudit(keyPromise: Promise<CryptoKey>, retentionDays?: number): void;
+    enableEncryption(keyPromise: Promise<CryptoKey>): void;
+    setMonitoring(api: CequreMonitoringAPI): void;
+    constructor(schema: CequreAST, config: CequreConfig);
+    get prefix(): string;
+    /** The raw prefix without version (e.g. "/api"). */
+    get rawPrefix(): string;
+    /** The current API version, or null if not configured. */
+    get apiVersion(): string | null;
+    /** Whether this version is deprecated (sends Deprecation/Sunset headers). */
+    get isDeprecatedVersion(): boolean;
+    access<K extends keyof TCollections, TAuthUser extends AuthUser = AuthUser>(collection: K, rules: AccessRules<TCollections[K], TCollections, TAuthUser>): void;
+    hooks<K extends keyof TCollections, TAuthUser extends AuthUser = AuthUser>(collection: K, hooks: Hooks<TCollections[K], TCollections, TAuthUser>): void;
+    checkLockout(collection: string, email: string, lockoutConfig?: {
+        maxAttempts?: number;
+        durationMinutes?: number;
+    }): Promise<{
+        locked: boolean;
+        remainingMs?: number;
+    }>;
+    recordFailedLogin(collection: string, email: string, lockoutConfig?: {
+        maxAttempts?: number;
+        durationMinutes?: number;
+    }): Promise<void>;
+    clearFailedLogins(collection: string, email: string): Promise<void>;
+    private resolveEnvVariables;
+    getContext(req: Request): Promise<CequreRequestContext>;
+    checkAccess(collection: string, action: keyof AccessRules, ctx: CequreRequestContext): Promise<WhereClause<any> | void>;
+    private runBeforeHooks;
+    private runAfterHooks;
+    private _registerCacheKey;
+    private initPlugins;
+    buildRoutes(): Promise<void>;
+    private auditLock;
+    /**
+     * Deletes audit log entries older than `retentionDays`.
+     * Called on a 24h interval by the retention timer, or can be invoked manually.
+     * Returns the count of deleted entries.
+     */
+    purgeOldAuditEntries(retentionDays: number): Promise<number>;
+    audit(event: CequreAuditEvent): Promise<void>;
+    private _doAudit;
+    /**
+     * Returns fields with role restrictions for a collection.
+     * Map: fieldName → roles that CAN access (empty array = no restriction).
+     */
+    private getRestrictedFields;
+    /**
+     * Strips fields the user's role is not allowed to access.
+     * Pass null userRole to strip all role-restricted fields (unauthenticated).
+     */
+    private filterFields;
+    /**
+     * Strips fields the user's role is not allowed to read.
+     * Pass null user to strip all role-restricted fields (unauthenticated).
+     */
+    private filterReadableFields;
+    /**
+     * Strips fields the user's role is not allowed to write.
+     * Returns the filtered data object.
+     */
+    private filterWritableFields;
+    /**
+     * Strips password and @omit fields from incoming data.
+     * These fields are never accepted in CRUD create/update —
+     * password only lives in auth endpoints, @omit fields are server-managed.
+     */
+    stripForbiddenFields(collection: string, data: Record<string, any>): Record<string, any>;
+    /**
+     * Returns the set of field names marked `encrypt: true` for a collection or global.
+     */
+    private getEncryptedFields;
+    /**
+     * Encrypts marked fields in a data object before writing to the adapter.
+     */
+    private encryptDataFields;
+    /**
+     * Decrypts encrypted fields in a document (or array of documents) after reading from the adapter.
+     */
+    private decryptDataFields;
+    secureCreate(collection: string, data: any): Promise<any>;
+    secureUpdate(collection: string, id: string, data: any): Promise<any>;
+    secureFind(collection: string, query: any): Promise<any>;
+    secureFindById(collection: string, id: string, query?: any): Promise<any>;
+    transaction<R>(callback: (trx: CequreRuntime<TCollections>) => Promise<R>): Promise<R>;
+    find<K extends keyof Omit<TCollections, "__populated">, D extends number = 0>(collection: K, query?: Omit<import("../core/adapter").QueryArgs<TCollections[K]>, "depth"> & {
+        depth?: D;
+    }): Promise<import("../core/adapter").PaginatedResult<D extends 0 ? TCollections[K] : "__populated" extends keyof TCollections ? (K extends keyof TCollections["__populated"] ? TCollections["__populated"][K] : TCollections[K]) : TCollections[K]>>;
+    findById<K extends keyof Omit<TCollections, "__populated">, D extends number = 0>(collection: K, id: string, query?: Omit<import("../core/adapter").QueryArgs<TCollections[K]>, "depth"> & {
+        depth?: D;
+    }): Promise<(D extends 0 ? TCollections[K] : "__populated" extends keyof TCollections ? (K extends keyof TCollections["__populated"] ? TCollections["__populated"][K] : TCollections[K]) : TCollections[K]) | null>;
+    create<K extends keyof TCollections>(collection: K, data: Partial<TCollections[K]>): Promise<TCollections[K]>;
+    update<K extends keyof TCollections>(collection: K, id: string, data: Partial<TCollections[K]>): Promise<TCollections[K]>;
+    delete<K extends keyof TCollections>(collection: K, id: string): Promise<void>;
+    /**
+     * Data Subject Erasure API (GDPR / SOC 2 Compliance)
+     * This is a backend-only method that permanently deletes a user record and
+     * attempts to cascade-delete or anonymize related PII across the system.
+     * It also revokes any active refresh tokens for the user.
+     */
+    eraseUser<K extends keyof TCollections>(collection: K, userId: string): Promise<void>;
+    count<K extends keyof TCollections>(collection: K, query?: Pick<import("../core/adapter").QueryArgs<TCollections[K]>, "where">): Promise<number>;
+    syncDatabaseSchema(): Promise<void>;
+    /**
+     * Schedule a recurring cron job
+     * @param name Unique identifier for the job
+     * @param schedule Cron expression (e.g. "0 * * * *")
+     * @param handler Async function to execute on schedule
+     */
+    cron(name: string, schedule: string, handler: (app: CequreRuntime<TCollections>) => unknown): void;
+    fetch(req: Request): Promise<Response>;
+    start(options?: {
+        port?: number;
+        drainTimeoutMs?: number;
+        tls?: {
+            cert: any;
+            key: any;
+            ca?: any;
+            passphrase?: string;
+            serverName?: string;
+        };
+    }): Promise<any>;
+}

package/dist/shared/main/sse.d.ts

@@ -0,0 +1,87 @@
+import type { AuthUser } from "./access";
+type MaybePromise<T> = T | Promise<T>;
+type BroadcastOptions = {
+    exclude?: string[];
+};
+type SSEConnection = {
+    id: string;
+    controller: ReadableStreamDefaultController<Uint8Array>;
+    channels: Set<string>;
+    request: Request;
+    user: AuthUser | null;
+    connectedAt: number;
+};
+type ConnectionInfo = {
+    id: string;
+    request: Request;
+    user: AuthUser | null;
+};
+type SubscribeInfo = ConnectionInfo & {
+    channel: string;
+};
+export declare class SSEManager {
+    private connections;
+    private channels;
+    private metadata;
+    register(connection: SSEConnection): void;
+    remove(id: string): void;
+    subscribe(id: string, channel: string): void;
+    unsubscribe(id: string, channel: string): void;
+    sendTo(id: string, payload: unknown): boolean;
+    broadcastToChannel(channel: string, payload: unknown, { exclude }?: BroadcastOptions): number;
+    broadcastAll(payload: unknown, { exclude }?: BroadcastOptions): number;
+    setMeta(id: string, key: string, value: unknown): void;
+    getMeta(id: string, key: string): unknown;
+    getChannelMembers(channel: string): string[];
+    getConnectionChannels(id: string): string[];
+    listChannels(): string[];
+    get connectionCount(): number;
+    get channelCount(): number;
+    getStats(): {
+        connections: number;
+        channels: {
+            [k: string]: number;
+        };
+    };
+}
+export declare const sseManager: SSEManager;
+export declare function createBunSSERoute({ path, heartbeat, resolveUser, onConnect, onSubscribe, }?: {
+    path?: string;
+    heartbeat?: {
+        interval?: number;
+        event?: string;
+        data?: unknown;
+    } | false;
+    resolveUser?: (request: Request) => MaybePromise<AuthUser | null>;
+    onConnect?: (info: ConnectionInfo) => MaybePromise<boolean | string>;
+    onSubscribe?: (info: SubscribeInfo) => MaybePromise<boolean | string>;
+}): (request: Request) => Promise<Response>;
+export declare class CequreSSE {
+    static get manager(): SSEManager;
+    static route(options?: Parameters<typeof createBunSSERoute>[0]): (request: Request) => Promise<Response>;
+    static register(connection: SSEConnection): void;
+    static remove(id: string): void;
+    static subscribe(id: string, channel: string): void;
+    static unsubscribe(id: string, channel: string): void;
+    static sendTo(id: string, payload: unknown): boolean;
+    static broadcastToChannel(channel: string, payload: unknown, opts?: {
+        exclude?: string[];
+    }): number;
+    static broadcastAll(payload: unknown, opts?: {
+        exclude?: string[];
+    }): number;
+    static setMeta(id: string, key: string, value: unknown): void;
+    static getMeta(id: string, key: string): unknown;
+    static getChannelMembers(channel: string): string[];
+    static getConnectionChannels(id: string): string[];
+    static listChannels(): string[];
+    static get connectionCount(): number;
+    static get channelCount(): number;
+    static getStats(): {
+        connections: number;
+        channels: {
+            [k: string]: number;
+        };
+    };
+}
+export {};

package/dist/shared/utils/crypto.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared crypto utilities used across the Cequre runtime.
+ *
+ * Centralises SHA-256 hex hashing and constant-time string comparison
+ * so that security modules (auth, audit, MFA) don't each roll their own.
+ */
+/**
+ * Deterministic SHA-256 hex hash of a string.
+ *
+ * ```ts
+ * const hash = await sha256Hex("hello");
+ * // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
+ * ```
+ */
+export declare function sha256Hex(input: string): Promise<string>;
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ *
+ * Returns `true` iff both strings are byte-for-byte equal.
+ * The comparison always iterates over the full length of `a`
+ * (or returns `false` immediately on length mismatch).
+ */
+export declare function timingSafeEqual(a: string, b: string): boolean;

package/dist/shared/utils/durable-queue.d.ts

@@ -0,0 +1,20 @@
+import type { CequreAdapter } from "../core/adapter";
+import type { StorageProvider } from "../core/types";
+export interface CequreJob<T = any> {
+    id: string;
+    task: string;
+    payload: T;
+    status: string;
+    retries: number;
+    error?: string;
+}
+export declare class CequreDurableQueue {
+    private adapter;
+    private storage?;
+    private intervalId?;
+    constructor(adapter: CequreAdapter, storage?: StorageProvider | undefined);
+    enqueue<T = any>(task: string, payload: T): Promise<void>;
+    startWorker(intervalMs?: number): void;
+    stopWorker(): void;
+    processNextBatch(): Promise<void>;
+}

package/dist/shared/utils/duration.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parse a shorthand duration string (e.g. `"5m"`, `"2h"`, `"1d"`) into seconds.
+ *
+ * Supported units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days).
+ * Falls back to `86400` (1 day) for unparseable input.
+ *
+ * ```ts
+ * parseDuration("30s");  // 30
+ * parseDuration("5m");   // 300
+ * parseDuration("2h");   // 7200
+ * parseDuration("1d");   // 86400
+ * parseDuration("bad");  // 86400 (fallback)
+ * ```
+ */
+export declare function parseDuration(duration: string): number;

package/dist/shared/utils/error.d.ts

@@ -0,0 +1,52 @@
+export declare class CequreError extends Error {
+    code: string;
+    status: number;
+    constructor(message: string, code?: string, status?: number);
+    toJSON(): {
+        error: string;
+        message: string;
+    };
+    static BadRequest: (message?: string) => CequreError;
+    static Unauthorized: (message?: string) => CequreError;
+    static NotImplemented: (message?: string) => CequreError;
+    static NotConfigured: (message?: string) => CequreError;
+    static Forbidden: (message?: string) => CequreError;
+    static NotFound: (message?: string) => CequreError;
+    static Conflict: (message?: string) => CequreError;
+    static TooManyRequests: (message?: string) => CequreError;
+    static SubscriptionRequired: (message?: string) => CequreError;
+    static Internal: (message?: string) => CequreError;
+}
+export interface CequreErrorResponse {
+    code: string;
+    message: string;
+    statusCode: number;
+    timestamp: string;
+    path?: string;
+}
+import type { ConstraintType, ParsedConstraintError, CequreAdapter } from "../core/adapter";
+/**
+ * Parse a database constraint error message and extract structured information.
+ * Relies on the provided database adapter to parse its specific errors.
+ */
+export declare function parseConstraintError(error: unknown, adapter?: CequreAdapter): ParsedConstraintError | null;
+/**
+ * Get a user-friendly message for a parsed constraint error.
+ */
+export declare function getConstraintErrorMessage(parsed: ParsedConstraintError): string;
+/**
+ * Get the appropriate HTTP status code for a constraint error type.
+ */
+export declare function getConstraintErrorStatus(type: ConstraintType): number;
+/**
+ * Build a structured error response body from any thrown value.
+ * - CequreError → uses its code/status/message directly.
+ * - Plain Error  → exposes message only in development (hides internals in production).
+ * - Database constraint errors → parsed and converted to user-friendly messages.
+ * - Unknown      → generic 500 message.
+ */
+export declare function buildErrorResponse(error: unknown, request?: Request, adapter?: CequreAdapter): CequreErrorResponse;
+/**
+ * Convert any thrown value to a JSON `Response` with the correct HTTP status.
+ */
+export declare function toErrorResponse(error: unknown, request?: Request, adapter?: CequreAdapter): Response;

package/dist/shared/utils/kv/adapters/memory.d.ts

@@ -0,0 +1,20 @@
+import type { KVAdapter } from "../types";
+export declare class MemoryAdapter implements KVAdapter {
+    private store;
+    get<T = unknown>(key: string): T | null;
+    getMany<T = unknown>(keys: string[]): Map<string, T>;
+    set(key: string, value: unknown, ttl?: number): void;
+    setMany(entries: Array<{
+        key: string;
+        value: unknown;
+        ttl?: number;
+    }>): void;
+    delete(key: string): boolean;
+    deleteMany(keys: string[]): number;
+    has(key: string): boolean;
+    keys(prefix?: string): string[];
+    count(): number;
+    clear(): void;
+    cleanup(): number;
+    close(): void;
+}

package/dist/shared/utils/kv/adapters/sqlite.d.ts

@@ -0,0 +1,32 @@
+import type { KVAdapter } from "../types";
+export declare class SQLiteAdapter implements KVAdapter {
+    private db;
+    private stmtGet;
+    private stmtSet;
+    private stmtDel;
+    private stmtHas;
+    private stmtKeys;
+    private stmtKeysPrefix;
+    private stmtClear;
+    private stmtCleanup;
+    private stmtCount;
+    constructor(options?: {
+        path?: string;
+    });
+    get<T = unknown>(key: string): Promise<T | null>;
+    getMany<T = unknown>(keys: string[]): Promise<Map<string, T>>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    setMany(entries: Array<{
+        key: string;
+        value: unknown;
+        ttl?: number;
+    }>): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<number>;
+    has(key: string): Promise<boolean>;
+    keys(prefix?: string): Promise<string[]>;
+    count(): Promise<number>;
+    clear(): Promise<void>;
+    cleanup(): number;
+    close(): void;
+}

package/dist/shared/utils/kv/index.d.ts

@@ -0,0 +1,37 @@
+import type { KVAdapter, KVOptions } from "./types";
+export * from "./types";
+/**
+ * A lightweight async key-value store facade that proxies to various drivers
+ * (Memory, SQLite, Redis) based on configuration.
+ *
+ * @example
+ * ```ts
+ * import { CequreKV } from "@cequrebackends/cequre-ts";
+ *
+ * const kv = new CequreKV({ driver: "memory" });
+ * await kv.set("user:1", { name: "Alice" }, 3600); // TTL 1 hour
+ * const user = await kv.get<{ name: string }>("user:1");
+ * ```
+ */
+export declare class CequreKV implements KVAdapter {
+    private adapter;
+    private cleanupTimer;
+    private isCleanupNative;
+    constructor(options?: KVOptions);
+    get<T = unknown>(key: string): Promise<T | null>;
+    getMany<T = unknown>(keys: string[]): Promise<Map<string, T>>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    setMany(entries: Array<{
+        key: string;
+        value: unknown;
+        ttl?: number;
+    }>): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<number>;
+    has(key: string): Promise<boolean>;
+    keys(prefix?: string): Promise<string[]>;
+    count(): Promise<number>;
+    clear(): Promise<void>;
+    cleanup(): Promise<number>;
+    close(): Promise<void>;
+}

package/dist/shared/utils/kv/types.d.ts

@@ -0,0 +1,38 @@
+export type KVDriverType = "memory" | "sqlite" | "redis";
+export interface KVOptions {
+    /** The storage driver to use. Default: "sqlite" */
+    driver?: KVDriverType;
+    /**
+     * Interval in milliseconds for automatic cleanup of expired entries (Memory/SQLite).
+     * Set to 0 to disable periodic cleanup. Default: 60_000 (1 minute)
+     */
+    cleanupInterval?: number;
+    /** Configuration for the SQLite driver */
+    sqlite?: {
+        /** Path to the SQLite database file. Default: "./data/cequre-kv.sqlite" */
+        path?: string;
+    };
+    /** Configuration for the Redis driver */
+    redis?: {
+        /** Redis connection URL. Default: "redis://localhost:6379" */
+        url?: string;
+    };
+}
+export interface KVAdapter {
+    get<T>(key: string): Promise<T | null> | T | null;
+    getMany<T>(keys: string[]): Promise<Map<string, T>> | Map<string, T>;
+    set(key: string, value: unknown, ttl?: number): Promise<void> | void;
+    setMany(entries: Array<{
+        key: string;
+        value: unknown;
+        ttl?: number;
+    }>): Promise<void> | void;
+    delete(key: string): Promise<boolean> | boolean;
+    deleteMany(keys: string[]): Promise<number> | number;
+    has(key: string): Promise<boolean> | boolean;
+    keys(prefix?: string): Promise<string[]> | string[];
+    count(): Promise<number> | number;
+    clear(): Promise<void> | void;
+    cleanup(): Promise<number> | number;
+    close(): Promise<void> | void;
+}

package/dist/shared/utils/logger.d.ts

@@ -0,0 +1,42 @@
+import pino from "pino";
+export declare const logger: pino.Logger<never, boolean>;
+export interface ErrorLogEntry {
+    key: string;
+    timestamp: number;
+    level: string;
+    message: string;
+    error?: string;
+    stack?: string;
+}
+/**
+ * CequreErrorLogs - Store and retrieve error logs using CequreKV
+ */
+export declare class CequreErrorLogs {
+    /**
+     * Get error logs from KV store.
+     *
+     * @param options.limit Max number of logs to return. Default: 100
+     * @param options.since Return logs after this timestamp (ms). Default: all
+     */
+    static get(options?: {
+        limit?: number;
+        since?: number;
+    }): Promise<ErrorLogEntry[]>;
+    /**
+     * Get error log count.
+     */
+    static count(): Promise<number>;
+    /**
+     * Clear all error logs.
+     */
+    static clear(): Promise<void>;
+}
+/**
+ * Creates a child logger scoped to a specific module / component.
+ *
+ * ```ts
+ * const log = createLogger("rest");
+ * log.info({ collection: "posts" }, "Route registered");
+ * ```
+ */
+export declare function createLogger(component: string): import("pino").Logger;

package/dist/shared/utils/queue-manager.d.ts

@@ -0,0 +1,64 @@
+import type { ConnectionOptions, JobsOptions, QueueOptions, WorkerOptions } from "bullmq";
+export interface BullMQConfig {
+    connection: ConnectionOptions;
+    prefix?: string;
+}
+export interface QueueSystemConfig {
+    bullmq: BullMQConfig;
+    defaultQueueOptions?: Omit<QueueOptions, "connection" | "prefix">;
+    defaultWorkerOptions?: Omit<WorkerOptions, "connection" | "prefix">;
+}
+export interface QueueJob<T = unknown> {
+    id?: string;
+    name: string;
+    data: T;
+    getState?: () => Promise<string>;
+}
+export interface QueueEventsLike {
+    disconnect(): Promise<void>;
+}
+export interface WorkerLike {
+    close(): Promise<void>;
+    waitUntilReady?: () => Promise<void>;
+}
+export interface QueueLike<T = unknown> {
+    add(name: string, data: T, opts?: JobOptions): Promise<QueueJob<T>>;
+    addBulk(jobs: BulkJobDefinition<T>[]): Promise<QueueJob<T>[]>;
+    getRepeatableJobs(): Promise<{
+        name: string;
+        key: string;
+    }[]>;
+    removeRepeatableByKey(key: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+}
+export type JobOptions = JobsOptions;
+export type JobHandler<T = unknown, R = unknown> = (job: QueueJob<T>) => Promise<R> | R;
+export interface QueueDefinition {
+    name: string;
+    options?: Omit<QueueOptions, "connection" | "prefix">;
+}
+export interface BulkJobDefinition<T = unknown> {
+    name: string;
+    data: T;
+    opts?: JobOptions;
+}
+export declare class CequreQueueManager {
+    private static instance;
+    private readonly queues;
+    private readonly workers;
+    private readonly queueEvents;
+    private readonly config;
+    private closing;
+    private constructor();
+    private getBullMQBaseOptions;
+    static initialize(config: QueueSystemConfig): CequreQueueManager;
+    static getInstance(): CequreQueueManager;
+    getQueue<T = unknown>(name: string): QueueLike<T>;
+    addJob<T = unknown>(queueName: string, jobName: string, data: T, opts?: JobOptions): Promise<QueueJob<T>>;
+    addBulk<T = unknown>(queueName: string, jobs: BulkJobDefinition<T>[]): Promise<QueueJob<T>[]>;
+    registerWorker<T = unknown>(queueName: string, handler: JobHandler<T>, options?: Omit<WorkerOptions, "connection" | "prefix">): Promise<WorkerLike>;
+    getQueueEvents(name: string): QueueEventsLike;
+    static _reset(): void;
+    static _resetAndClose(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/shared/utils/url.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extract the pathname from a URL string without allocating a `URL` object.
+ *
+ * Handles full URLs (`http://host/api/users?foo=1`), path-only strings
+ * (`/api/users?foo=1`), and edge cases like hash fragments.
+ *
+ * ```ts
+ * extractPathname("http://localhost:3000/api/users/123?name=John");  // "/api/users/123"
+ * extractPathname("/api/users?limit=10");  // "/api/users"
+ * extractPathname("/");                     // "/"
+ * ```
+ */
+export declare function extractPathname(url: string): string;