@tstdl/base 0.93.174 → 0.93.176

package/api/server/middlewares/response-time.middleware.js

@@ -1,8 +1,5 @@
-import { round } from '../../../utils/math.js';
-import { Timer } from '../../../utils/timer.js';
 export async function responseTimeMiddleware({ response }, next) {
-    const timer = Timer.startNew();
+    const stop = response.serverTiming.start('total');
     await next();
-    const time = round(timer.milliseconds, 2);
-    response.headers.set('X-Response-Time', `${time}ms`);
+    stop();
 }

package/audit/auditor.js

@@ -235,7 +235,7 @@ __decorate([
 Auditor = Auditor_1 = __decorate([
     Injectable({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(AuditModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(AuditModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], Auditor);

package/authentication/client/authentication.service.js

@@ -421,6 +421,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                 // 2. Handle token refresh
                 if (needsRefresh) {
                     const lockResult = await this.lock.tryUse(undefined, async () => {
+                        this.loadToken();
                         const currentToken = this.token();
                         if (isUndefined(currentToken)) {
                             return;
@@ -442,6 +443,18 @@ let AuthenticationClientService = class AuthenticationClientService {
                             this.forceRefreshRequested.set(false);
                         }
                     }
+                    // Protection against tight loops (e.g. if server clock is ahead and sync failed)
+                    const newToken = this.token();
+                    if (isDefined(newToken)) {
+                        const newNow = this.estimatedServerTimestampSeconds();
+                        const newBuffer = calculateRefreshBufferSeconds(newToken);
+                        const stillNeedsRefresh = this.forceRefreshRequested() || (newNow >= newToken.exp - newBuffer);
+                        if (stillNeedsRefresh) {
+                            this.logger.warn('Token still needs refresh after attempt. Waiting for minRefreshDelay to avoid tight loop.');
+                            await waitForNextAction(minRefreshDelay, newToken.exp);
+                        }
+                    }
+                    await waitForNextAction(100, newToken?.exp);
                     continue; // Re-evaluate the loop with the newly refreshed (or synced) token
                 }
                 // 3. Calculate delay and sleep until the next scheduled refresh window

package/authentication/server/authentication.service.d.ts

@@ -57,7 +57,7 @@ export declare class AuthenticationServiceOptions {
     /**
      * How long a refresh token is valid in milliseconds. Implies session time to live.
      *
-     * @default 1 hour
+     * @default 6 hours
      */
     refreshTokenTimeToLive?: number;
     /**

package/authentication/server/authentication.service.js

@@ -55,7 +55,7 @@ export class AuthenticationServiceOptions {
     /**
      * How long a refresh token is valid in milliseconds. Implies session time to live.
      *
-     * @default 1 hour
+     * @default 6 hours
      */
     refreshTokenTimeToLive;
     /**
@@ -126,7 +126,7 @@ let AuthenticationService = AuthenticationService_1 = class AuthenticationServic
     };
     tokenVersion = this.#options.version ?? 1;
     tokenTimeToLive = this.#options.tokenTimeToLive ?? (5 * millisecondsPerMinute);
-    refreshTokenTimeToLive = this.#options.refreshTokenTimeToLive ?? (1 * millisecondsPerHour);
+    refreshTokenTimeToLive = this.#options.refreshTokenTimeToLive ?? (6 * millisecondsPerHour);
     rememberRefreshTokenTimeToLive = this.#options.rememberRefreshTokenTimeToLive ?? (30 * millisecondsPerDay);
     secretResetTokenTimeToLive = this.#options.secretResetTokenTimeToLive ?? (10 * millisecondsPerMinute);
     derivedTokenSigningSecret;
@@ -787,7 +787,7 @@ let AuthenticationService = AuthenticationService_1 = class AuthenticationServic
 AuthenticationService = AuthenticationService_1 = __decorate([
     Singleton({
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], AuthenticationService);

package/authentication/tests/authentication.client-service-refresh.test.js

@@ -130,4 +130,23 @@ describe('AuthenticationClientService Refresh Loop Reproduction', () => {
         await service.refresh();
         expect(mockApiClient.timestamp).toHaveBeenCalled();
     });
+    test('Cross-tab Sync: should not refresh if another tab already did (simulated via localStorage update)', async () => {
+        const now = Math.floor(Date.now() / 1000);
+        const initialToken = { iat: now - 3600, exp: now + 5, jti: 'initial' }; // Expiring soon
+        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
+        // 1. Mock lock behavior to simulate another tab refreshing while we wait for the lock
+        mockLock.tryUse.mockImplementation(async (_timeout, callback) => {
+            // Simulate another tab refreshing and updating localStorage
+            const newToken = { iat: now, exp: now + 3600, jti: 'refreshed-by-other-tab' };
+            globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(newToken));
+            const result = await callback({ lost: false });
+            return { success: true, result };
+        });
+        service = injector.resolve(AuthenticationClientService);
+        // Wait for loop to run
+        await timeout(100);
+        // Should NOT have called refresh because loadToken() inside the lock updated the token
+        expect(mockApiClient.refresh).not.toHaveBeenCalled();
+        expect(service.token()?.jti).toBe('refreshed-by-other-tab');
+    });
 });

package/authentication/tests/authentication.refresh-busy-loop.test.d.ts

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

package/authentication/tests/authentication.refresh-busy-loop.test.js

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
+import { AUTHENTICATION_API_CLIENT } from '../../authentication/client/tokens.js';
+import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
+import { Injector } from '../../injector/index.js';
+import { Lock } from '../../lock/index.js';
+import { Logger } from '../../logger/index.js';
+import { MessageBus } from '../../message-bus/index.js';
+import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
+import { timeout } from '../../utils/timing.js';
+import { Subject } from 'rxjs';
+describe('AuthenticationClientService Refresh Busy Loop Prevention', () => {
+    let injector;
+    let service;
+    let mockApiClient;
+    let mockLock;
+    let mockMessageBus;
+    let mockLogger;
+    let disposeToken;
+    beforeEach(() => {
+        const storage = new Map();
+        globalThis.localStorage = {
+            getItem: vi.fn((key) => storage.get(key) ?? null),
+            setItem: vi.fn((key, value) => storage.set(key, value)),
+            removeItem: vi.fn((key) => storage.delete(key)),
+            clear: vi.fn(() => storage.clear()),
+        };
+        configureDefaultSignalsImplementation();
+        injector = new Injector('Test');
+        mockApiClient = {
+            login: vi.fn(),
+            refresh: vi.fn(),
+            timestamp: vi.fn().mockResolvedValue(1000), // Fixed timestamp
+            endSession: vi.fn().mockResolvedValue(undefined),
+        };
+        mockLock = {
+            tryUse: vi.fn(async (_timeout, callback) => {
+                const result = await callback({ lost: false });
+                return { success: true, result };
+            }),
+            use: vi.fn(async (_timeout, callback) => {
+                return await callback({ lost: false });
+            }),
+        };
+        mockMessageBus = {
+            publishAndForget: vi.fn(),
+            messages$: new Subject(),
+            dispose: vi.fn(),
+        };
+        mockLogger = {
+            error: vi.fn(),
+            warn: vi.fn(),
+            info: vi.fn(),
+            debug: vi.fn(),
+        };
+        injector.register(AUTHENTICATION_API_CLIENT, { useValue: mockApiClient });
+        injector.register(Lock, { useValue: mockLock });
+        injector.register(MessageBus, { useValue: mockMessageBus });
+        injector.register(Logger, { useValue: mockLogger });
+        disposeToken = new CancellationToken();
+        injector.register(CancellationSignal, { useValue: disposeToken.signal });
+    });
+    afterEach(async () => {
+        disposeToken.set();
+        await injector.dispose();
+    });
+    test('should not busy loop when refresh fails to produce a valid token', async () => {
+        // 1. Mock a token that is ALWAYS expired
+        // Server time is 1000. Token expires at 500.
+        const expiredToken = { iat: 0, exp: 500, jti: 'expired', session: 's', tenant: 't', subject: 'sub' };
+        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(expiredToken));
+        // refresh() will return the SAME expired token
+        mockApiClient.refresh.mockResolvedValue(expiredToken);
+        // 2. Start service
+        service = injector.resolve(AuthenticationClientService);
+        // 3. Wait a bit
+        // With 100ms mandatory yield + minRefreshDelay (1 min) protection, it should only try once or twice in 500ms
+        // WITHOUT protection, it would try thousands of times.
+        await timeout(500);
+        // It should have tried to refresh
+        expect(mockApiClient.refresh.mock.calls.length).toBeLessThan(5);
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Token still needs refresh after attempt'));
+    });
+});

package/circuit-breaker/postgres/circuit-breaker.js

@@ -93,7 +93,7 @@ PostgresCircuitBreakerService = __decorate([
     Singleton({
         argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.key,
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], PostgresCircuitBreakerService);

package/document-management/server/services/singleton.js

@@ -3,7 +3,7 @@ import { provide } from '../../../injector/injector.js';
 import { factoryProvider } from '../../../injector/provider.js';
 import { DatabaseConfig } from '../../../orm/server/index.js';
 import { DocumentManagementConfiguration } from '../module.js';
-export const documentManagementDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(DocumentManagementConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }));
+export const documentManagementDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(DocumentManagementConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }));
 export const documentManagementDatabaseConfigProvider = provide(DatabaseConfig, documentManagementDatabaseConfigFactoryProvider);
 export function DocumentManagementSingleton() {
     return Singleton({ providers: [documentManagementDatabaseConfigProvider] });

package/errors/format.d.ts

@@ -1,4 +1,4 @@
-import type { Record, UndefinableJson } from '../types/index.js';
+import type { ObjectLiteral, Record, UndefinableJson } from '../types/index.js';
 export type FormatErrorOptions = {
     /** Include error name in message */
     includeName?: boolean;
@@ -20,6 +20,11 @@ export type SerializedError = {
     cause?: SerializedError;
     aggregateErrors?: SerializedError[];
 };
+export type NonRecursiveSerializedError = Omit<SerializedError, 'extraInfo' | 'cause' | 'aggregateErrors'> & {
+    extraInfo?: ObjectLiteral | null | undefined;
+    cause?: ObjectLiteral;
+    aggregateErrors?: ObjectLiteral[];
+};
 export interface ErrorExtraInfo {
     /** Format extra data (without message and stack) as JSON */
     getExtraInfo(): UndefinableJson | undefined;

package/errors/format.js

@@ -29,7 +29,7 @@ export function serializeError(error, options = {}) {
             aggregateErrors = actualError.errors;
         }
         // Extract Extra Info
-        if (includeExtraInfo && isFunction(actualError.getExtraInfo)) {
+        if (includeExtraInfo && isFunction(actualError?.getExtraInfo)) {
             extraInfo = actualError.getExtraInfo();
         }
         // Isolate 'rest' properties via destructuring

package/http/index.d.ts

@@ -12,6 +12,7 @@ export * from './http-query.js';
 export * from './http-url-parameters.js';
 export * from './http-value-map.js';
 export * from './http.error.js';
+export * from './server-timing.js';
 export * from './server/index.js';
 export * from './tokens.js';
 export * from './types.js';

package/http/index.js

@@ -12,6 +12,7 @@ export * from './http-query.js';
 export * from './http-url-parameters.js';
 export * from './http-value-map.js';
 export * from './http.error.js';
+export * from './server-timing.js';
 export * from './server/index.js';
 export * from './tokens.js';
 export * from './types.js';

package/http/server/http-server-response.d.ts

@@ -3,6 +3,7 @@ import type { ServerSentEventsSource } from '../../sse/server-sent-events-source
 import type { Record } from '../../types/index.js';
 import type { HttpHeadersInput } from '../http-headers.js';
 import { HttpHeaders } from '../http-headers.js';
+import { ServerTiming } from '../server-timing.js';
 export type SetCookieObject = SetCookieOptions & {
     value: string;
 };
@@ -24,6 +25,7 @@ export type HttpServerResponseOptions = {
 export declare class HttpServerResponse {
     #private;
     readonly headers: HttpHeaders;
+    readonly serverTiming: ServerTiming;
     statusCode: number | undefined;
     statusMessage: string | undefined;
     get body(): HttpServerResponseBody | undefined;

package/http/server/http-server-response.js

@@ -2,10 +2,12 @@ import { formatSetCookie } from '../../cookie/cookie.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { isDefined, isUndefined } from '../../utils/type-guards.js';
 import { HttpHeaders } from '../http-headers.js';
+import { ServerTiming } from '../server-timing.js';
 export class HttpServerResponse {
     #body;
     #bodyType;
     headers = new HttpHeaders();
+    serverTiming = new ServerTiming();
     statusCode;
     statusMessage;
     get body() {

package/http/server/node/node-http-server.js

@@ -141,6 +141,9 @@ function getResponder(httpResponse) {
     return respond;
 }
 function writeHeaders(response, httpResponse) {
+    if (response.serverTiming.hasMetrics) {
+        response.headers.set('Server-Timing', response.serverTiming.toString());
+    }
     for (const [name, value] of response.headers.normalizedEntries()) {
         httpResponse.setHeader(name, value);
     }

package/http/server-timing.d.ts

@@ -0,0 +1,31 @@
+export type ServerTimingMetric = {
+    name: string;
+    duration?: number;
+    description?: string;
+};
+export declare class ServerTiming {
+    #private;
+    /**
+     * Whether there are any metrics.
+     */
+    get hasMetrics(): boolean;
+    /**
+     * Add a metric to the server timing.
+     * @param name The name of the metric.
+     * @param duration The duration of the metric in milliseconds.
+     * @param description An optional description for the metric.
+     */
+    add(name: string, duration?: number, description?: string): void;
+    /**
+     * Start a timer for a metric.
+     * @param name The name of the metric.
+     * @param description An optional description for the metric.
+     * @returns A function to stop the timer and add the metric.
+     */
+    start(name: string, description?: string): () => void;
+    /**
+     * Format the metrics as a `Server-Timing` header value.
+     * @returns Comma-separated list of metrics.
+     */
+    toString(): string;
+}

package/http/server-timing.js

@@ -0,0 +1,47 @@
+import { round } from '../utils/math.js';
+import { Timer } from '../utils/timer.js';
+import { isDefined } from '../utils/type-guards.js';
+export class ServerTiming {
+    #metrics = [];
+    /**
+     * Whether there are any metrics.
+     */
+    get hasMetrics() {
+        return this.#metrics.length > 0;
+    }
+    /**
+     * Add a metric to the server timing.
+     * @param name The name of the metric.
+     * @param duration The duration of the metric in milliseconds.
+     * @param description An optional description for the metric.
+     */
+    add(name, duration, description) {
+        this.#metrics.push({ name, duration, description });
+    }
+    /**
+     * Start a timer for a metric.
+     * @param name The name of the metric.
+     * @param description An optional description for the metric.
+     * @returns A function to stop the timer and add the metric.
+     */
+    start(name, description) {
+        const timer = Timer.startNew();
+        return () => this.add(name, round(timer.milliseconds, 2), description);
+    }
+    /**
+     * Format the metrics as a `Server-Timing` header value.
+     * @returns Comma-separated list of metrics.
+     */
+    toString() {
+        return this.#metrics.map((metric) => {
+            let result = metric.name;
+            if (isDefined(metric.duration)) {
+                result += `;dur=${metric.duration}`;
+            }
+            if (isDefined(metric.description)) {
+                result += `;desc="${metric.description}"`;
+            }
+            return result;
+        }).join(', ');
+    }
+}

package/http/tests/server-timing.test.d.ts

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

package/http/tests/server-timing.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { ServerTiming } from '../server-timing.js';
+describe('ServerTiming', () => {
+    test('should be empty by default', () => {
+        const timing = new ServerTiming();
+        expect(timing.hasMetrics).toBe(false);
+        expect(timing.toString()).toBe('');
+    });
+    test('should add a simple metric', () => {
+        const timing = new ServerTiming();
+        timing.add('db');
+        expect(timing.hasMetrics).toBe(true);
+        expect(timing.toString()).toBe('db');
+    });
+    test('should add a metric with duration', () => {
+        const timing = new ServerTiming();
+        timing.add('db', 53.2);
+        expect(timing.toString()).toBe('db;dur=53.2');
+    });
+    test('should add a metric with duration and description', () => {
+        const timing = new ServerTiming();
+        timing.add('db', 53.2, 'Database Query');
+        expect(timing.toString()).toBe('db;dur=53.2;desc="Database Query"');
+    });
+    test('should add multiple metrics', () => {
+        const timing = new ServerTiming();
+        timing.add('cache', undefined, 'Cache Miss');
+        timing.add('db', 53.2);
+        timing.add('total', 123.45);
+        expect(timing.toString()).toBe('cache;desc="Cache Miss", db;dur=53.2, total;dur=123.45');
+    });
+    test('should use start/stop for metrics', async () => {
+        const timing = new ServerTiming();
+        const stop = timing.start('total');
+        await new Promise((resolve) => setTimeout(resolve, 11));
+        stop();
+        const result = timing.toString();
+        expect(result).toMatch(/total;dur=\d+\.\d+/);
+        const duration = Number.parseFloat(result.split('=')[1]);
+        expect(duration).toBeGreaterThanOrEqual(10);
+    });
+});

package/key-value-store/postgres/key-value-store.service.js

@@ -56,7 +56,7 @@ let PostgresKeyValueStore = class PostgresKeyValueStore extends Transactional {
 PostgresKeyValueStore = __decorate([
     Singleton({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresKeyValueStoreModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresKeyValueStoreModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], PostgresKeyValueStore);

package/lock/postgres/provider.js

@@ -20,7 +20,7 @@ let PostgresLockProvider = class PostgresLockProvider extends LockProvider {
 PostgresLockProvider = __decorate([
     Singleton({
         providers: [
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresLockModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) },
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresLockModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
         ],
     })
 ], PostgresLockProvider);

package/mail/README.md

@@ -203,7 +203,7 @@ export class MarketingService {
         subject: 'Weekly Newsletter',
         content: { text: '...' },
       },
-      marketingConfig, // Override config
+      { clientConfig: marketingConfig },
     );
   }
 }

package/mail/drizzle/0001_married_tarantula.sql

@@ -0,0 +1,10 @@
+ALTER TABLE "mail"."log" ALTER COLUMN "errors" SET DATA TYPE jsonb USING (
+  CASE 
+    WHEN "errors" IS NULL THEN '[]'::jsonb
+    ELSE (
+      SELECT COALESCE(jsonb_agg(jsonb_build_object('message', err)), '[]'::jsonb)
+      FROM unnest("errors") AS err
+    )
+  END
+);--> statement-breakpoint
+ALTER TABLE "mail"."log" ALTER COLUMN "errors" SET NOT NULL;

package/mail/drizzle/meta/0001_snapshot.json

@@ -0,0 +1,69 @@
+{
+  "id": "c74f667f-8acf-42e7-ad58-3aea45df3743",
+  "prevId": "0c48afa4-9ab0-4965-a93e-05a6c1b88e58",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "mail.log": {
+      "name": "log",
+      "schema": "mail",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "timestamp": {
+          "name": "timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "template": {
+          "name": "template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "send_result": {
+          "name": "send_result",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "errors": {
+          "name": "errors",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/mail/drizzle/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1771240070681,
       "tag": "0000_numerous_the_watchers",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1774305325041,
+      "tag": "0001_married_tarantula",
+      "breakpoints": true
     }
   ]
 }

package/mail/index.d.ts

@@ -8,4 +8,5 @@ export * from './mail.client.js';
 export * from './mail.service.js';
 export * from './models/index.js';
 export * from './module.js';
+export * from './task-definitions.js';
 export * from './tokens.js';

package/mail/index.js

@@ -8,4 +8,5 @@ export * from './mail.client.js';
 export * from './mail.service.js';
 export * from './models/index.js';
 export * from './module.js';
+export * from './task-definitions.js';
 export * from './tokens.js';

package/mail/mail.service.d.ts

@@ -1,10 +1,27 @@
+import type { AfterResolveContext } from '../injector/index.js';
+import { afterResolve } from '../injector/index.js';
+import type { Transaction } from '../orm/server/transaction.js';
 import type { TypedOmit } from '../types/index.js';
 import { MailClientConfig } from './mail.client.js';
 import { type MailData, type MailSendResult, type MailTemplate } from './models/index.js';
+export type MailSendOptions = {
+    clientConfig?: MailClientConfig;
+    /** @internal */
+    templateName?: string;
+};
 export declare class MailService {
     #private;
-    send(mailData: MailData, clientConfig?: MailClientConfig): Promise<MailSendResult>;
-    /** @deprecated internal */
-    send(mailData: MailData, clientConfig?: MailClientConfig, templateName?: string): Promise<MailSendResult>;
-    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, clientConfig?: MailClientConfig): Promise<MailSendResult>;
+    [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext): void;
+    send(mailData: MailData, options?: MailSendOptions): Promise<MailSendResult>;
+    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, options?: MailSendOptions): Promise<MailSendResult>;
+    enqueue(mailData: MailData, options?: {
+        transaction?: Transaction;
+        priority?: number;
+        delay?: number;
+    }): Promise<void>;
+    enqueueTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context, options?: {
+        transaction?: Transaction;
+        priority?: number;
+        delay?: number;
+    }): Promise<void>;
 }