alepha 0.10.6 → 0.10.7

package/core.d.ts

@@ -28,13 +28,13 @@ declare const MODULE: unique symbol;
 /**
  * In Alepha, a service is a class that can be instantiated or an abstract class. Nothing more, nothing less...
  */
-type Service<T extends object = any> = InstantiableClass<T> | AbstractClass<T>;
-type InstantiableClass<T extends object = any> = new (...args: any[]) => T;
+type Service<T$1 extends object = any> = InstantiableClass<T$1> | AbstractClass<T$1>;
+type InstantiableClass<T$1 extends object = any> = new (...args: any[]) => T$1;
 /**
  * Abstract class is a class that cannot be instantiated directly!
  * It widely used for defining interfaces.
  */
-type AbstractClass<T extends object = any> = abstract new (...args: any[]) => T;
+type AbstractClass<T$1 extends object = any> = abstract new (...args: any[]) => T$1;
 /**
  * Service substitution allows you to register a class as a different class.
  * Providing class A, but using class B instead.
@@ -42,17 +42,17 @@ type AbstractClass<T extends object = any> = abstract new (...args: any[]) => T;
  *
  * class A is mostly an AbstractClass, while class B is an InstantiableClass.
  */
-interface ServiceSubstitution<T extends object = any> {
+interface ServiceSubstitution<T$1 extends object = any> {
   /**
    * Every time someone asks for this class, it will be provided with the 'use' class.
    */
-  provide: Service<T>;
+  provide: Service<T$1>;
   /**
    * Service to use instead of the 'provide' service.
    *
    * Syntax is inspired by Angular's DI system.
    */
-  use: Service<T>;
+  use: Service<T$1>;
   /**
    * If true, if the service already exists -> just ignore the substitution and do not throw an error.
    * Mostly used for plugins to enforce a substitution without throwing an error.
@@ -68,11 +68,11 @@ interface ServiceSubstitution<T extends object = any> {
  *
  * And yes, you declare the *type* of the service, not the *instance*.
  */
-type ServiceEntry<T extends object = any> = Service<T> | ServiceSubstitution<T>;
+type ServiceEntry<T$1 extends object = any> = Service<T$1> | ServiceSubstitution<T$1>;
 //#endregion
 //#region src/helpers/descriptor.d.ts
-interface DescriptorArgs<T extends object = {}> {
-  options: T;
+interface DescriptorArgs<T$1 extends object = {}> {
+  options: T$1;
   alepha: Alepha;
   service: InstantiableClass<Service>;
   module?: Service;
@@ -82,22 +82,22 @@ interface DescriptorConfig {
   service: InstantiableClass<Service>;
   module?: Service;
 }
-declare abstract class Descriptor<T extends object = {}> {
+declare abstract class Descriptor<T$1 extends object = {}> {
   protected readonly alepha: Alepha;
-  readonly options: T;
+  readonly options: T$1;
   readonly config: DescriptorConfig;
-  constructor(args: DescriptorArgs<T>);
+  constructor(args: DescriptorArgs<T$1>);
   /**
    * Called automatically by Alepha after the descriptor is created.
    */
   protected onInit(): void;
 }
-type DescriptorFactory<TDescriptor extends Descriptor = Descriptor> = {
-  (options: TDescriptor["options"]): TDescriptor;
-  [KIND]: InstantiableClass<TDescriptor>;
+type DescriptorFactory<TDescriptor$1 extends Descriptor = Descriptor> = {
+  (options: TDescriptor$1["options"]): TDescriptor$1;
+  [KIND]: InstantiableClass<TDescriptor$1>;
 };
-type DescriptorFactoryLike<T extends object = any> = {
-  (options: T): any;
+type DescriptorFactoryLike<T$1 extends object = any> = {
+  (options: T$1): any;
   [KIND]: any;
 };
 declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: InstantiableClass<TDescriptor> & {
@@ -117,7 +117,7 @@ declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: Ins
  */
 declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
 declare class InjectDescriptor extends Descriptor {}
-interface InjectOptions<T extends object = any> {
+interface InjectOptions<T$1 extends object = any> {
   /**
    * - 'transient' → Always a new instance on every inject. Zero caching.
    * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
@@ -132,7 +132,7 @@ interface InjectOptions<T extends object = any> {
   /**
    * Constructor arguments to pass when creating a new instance.
    */
-  args?: ConstructorParameters<InstantiableClass<T>>;
+  args?: ConstructorParameters<InstantiableClass<T$1>>;
   /**
    * Parent that requested the instance.
    *
@@ -190,7 +190,7 @@ interface InjectOptions<T extends object = any> {
  * If we speak with `$actions`, a module should be used when you have more than 30 actions in a single module.
  */
 declare const $module: <T extends object = {}>(options: ModuleDescriptorOptions<T>) => Service<Module<T>>;
-interface ModuleDescriptorOptions<T extends object> {
+interface ModuleDescriptorOptions<T$1 extends object> {
   /**
    * Name of the module.
    *
@@ -210,16 +210,16 @@ interface ModuleDescriptorOptions<T extends object> {
    * You can override this behavior by providing a register function.
    * It's useful when you want to register services conditionally or in a specific order.
    */
-  register?: (alepha: Alepha, options: T) => void;
+  register?: (alepha: Alepha, options: T$1) => void;
 }
 /**
  * Base class for all modules.
  */
-declare abstract class Module<T extends object = {}> {
-  abstract readonly config: ModuleDescriptorOptions<T>;
+declare abstract class Module<T$1 extends object = {}> {
+  abstract readonly config: ModuleDescriptorOptions<T$1>;
   abstract register(alepha: Alepha): void;
   static NAME_REGEX: RegExp;
-  options: T;
+  options: T$1;
   /**
    * Check if a Service is a Module.
    */
@@ -229,7 +229,7 @@ declare abstract class Module<T extends object = {}> {
    */
   static of(ctor: Service): Service<Module> | undefined;
 }
-type WithModule<T extends object = any> = T & {
+type WithModule<T$1 extends object = any> = T$1 & {
   [MODULE]?: Service;
 };
 //#endregion
@@ -237,7 +237,7 @@ type WithModule<T extends object = any> = T & {
 /**
  * Represents a value that can be either a value or a promise of value.
  */
-type Async<T> = T | Promise<T>;
+type Async<T$1> = T$1 | Promise<T$1>;
 /**
  * Represents a function that returns an async value.
  */
@@ -245,7 +245,7 @@ type AsyncFn = (...args: any[]) => Async<any>;
 /**
  * Transforms a type T into a promise if it is not already a promise.
  */
-type MaybePromise<T> = T extends Promise<any> ? T : Promise<T>;
+type MaybePromise<T$1> = T$1 extends Promise<any> ? T$1 : Promise<T$1>;
 //#endregion
 //#region src/interfaces/LoggerInterface.d.ts
 type LogLevel = "ERROR" | "WARN" | "INFO" | "DEBUG" | "TRACE" | "SILENT";
@@ -273,7 +273,7 @@ declare class EventManager {
   /**
    * Emits the specified event with the given payload.
    */
-  emit<T extends keyof Hooks>(func: keyof Hooks, payload: Hooks[T], options?: {
+  emit<T extends keyof Hooks>(func: T, payload: Hooks[T], options?: {
     /**
      * If true, the hooks will be executed in reverse order.
      * This is useful for "stop" hooks that should be executed in reverse order.
@@ -630,10 +630,26 @@ declare class TypeProvider {
    * @experimental
    */
   stream(): TStream;
+  email(options?: TStringOptions$1): TString$1;
+  e164(options?: TStringOptions$1): TString$1;
+  bcp47(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for short text, such as names or titles.
+   * Default max length is 64 characters.
+   */
+  shortText(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for long text, such as descriptions or comments.
+   * Default max length is 1024 characters.
+   */
+  longText(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for rich text, such as HTML or Markdown.
+   * Default max length is 65535 characters.
+   */
+  richText(options?: TStringOptions$1): TString$1;
   /**
    * Create a schema for a string enum e.g. LIKE_THIS.
-   *
-   * @param options
    */
   snakeCase: (options?: TStringOptions$1) => TString$1;
   /**
@@ -935,12 +951,14 @@ declare class Alepha {
    * True if the App is running in a browser environment.
    */
   isBrowser(): boolean;
+  /**
+   * Returns whether the App is running in Vite dev mode.
+   */
+  isViteDev(): boolean;
   /**
    * Returns whether the App is running in a serverless environment.
-   *
-   * > Vite developer mode is also considered serverless.
    */
-  isServerless(): boolean | "vite" | "vercel";
+  isServerless(): boolean | "vercel";
   /**
    * Returns whether the App is in test mode. (Running in a test environment)
    *
@@ -1126,20 +1144,20 @@ declare class Alepha {
   protected new<T extends object>(service: Service<T>, args?: any[]): T;
   protected processDescriptor(value: Descriptor, propertyKey?: string): void;
 }
-interface Hook<T extends keyof Hooks = any> {
+interface Hook<T$1 extends keyof Hooks = any> {
   caller?: Service;
   priority?: "first" | "last";
-  callback: (payload: Hooks[T]) => Async<void>;
+  callback: (payload: Hooks[T$1]) => Async<void>;
 }
 /**
  * This is how we store services in the Alepha container.
  */
-interface ServiceDefinition<T extends object = any> {
+interface ServiceDefinition<T$1 extends object = any> {
   /**
    * The instance of the class or type definition.
    * Mostly used for caching / singleton but can be used for other purposes like forcing the instance.
    */
-  instance: T;
+  instance: T$1;
   /**
    * List of classes which use this class.
    */
@@ -1211,6 +1229,9 @@ interface Hooks {
     prevValue: any;
   };
 }
+interface Configurable<T$1 extends object = any> {
+  options: T$1;
+}
 //#endregion
 //#region src/interfaces/Run.d.ts
 interface RunOptions {
@@ -1366,15 +1387,15 @@ declare const $hook: {
   <T extends keyof Hooks>(options: HookOptions<T>): HookDescriptor<T>;
   [KIND]: typeof HookDescriptor;
 };
-interface HookOptions<T extends keyof Hooks> {
+interface HookOptions<T$1 extends keyof Hooks> {
   /**
    * The name of the hook. "configure", "start", "ready", "stop", ...
    */
-  on: T;
+  on: T$1;
   /**
    * The handler to run when the hook is triggered.
    */
-  handler: (args: Hooks[T]) => Async<any>;
+  handler: (args: Hooks[T$1]) => Async<any>;
   /**
    * Force the hook to run first or last on the list of hooks.
    */
@@ -1388,7 +1409,7 @@ interface HookOptions<T extends keyof Hooks> {
    */
   after?: object | Array<object>;
 }
-declare class HookDescriptor<T extends keyof Hooks> extends Descriptor<HookOptions<T>> {
+declare class HookDescriptor<T$1 extends keyof Hooks> extends Descriptor<HookOptions<T$1>> {
   called: number;
   protected onInit(): void;
 }
@@ -1447,5 +1468,5 @@ declare global {
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => void;
 //#endregion
-export { $cursor, $env, $hook, $inject, $module, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, CircularDependencyError, ContainerLockedError, CursorDescriptor, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, Service, ServiceEntry, ServiceSubstitution, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, __alephaRef, createDescriptor, isDate, isDateTime, isEmail, isFileLike, isTypeFile, isURL, isUUID, run, t };
+export { $cursor, $env, $hook, $inject, $module, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, CircularDependencyError, Configurable, ContainerLockedError, CursorDescriptor, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, Service, ServiceEntry, ServiceSubstitution, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, __alephaRef, createDescriptor, isDate, isDateTime, isEmail, isFileLike, isTypeFile, isURL, isUUID, run, t };
 //# sourceMappingURL=index.d.ts.map

package/email.d.ts

@@ -1,5 +1,4 @@
 import * as _alepha_core1 from "alepha";
-import { Descriptor, KIND, Service, Static, TSchema } from "alepha";
 import * as _alepha_logger0 from "alepha/logger";
 import { Transporter } from "nodemailer";
 
@@ -13,230 +12,15 @@ declare abstract class EmailProvider {
   /**
    * Send an email.
    *
-   * @param to The recipient email address.
-   * @param subject The email subject.
-   * @param body The email body (HTML content).
-   *
    * @return Promise that resolves when the email is sent.
    */
-  abstract send(to: string, subject: string, body: string): Promise<void>;
+  abstract send(options: EmailSendOptions): Promise<void>;
 }
-//#endregion
-//#region src/providers/MemoryEmailProvider.d.ts
-interface EmailRecord {
-  to: string;
+type EmailSendOptions = {
+  to: string | string[];
   subject: string;
   body: string;
-  sentAt: Date;
-}
-declare class MemoryEmailProvider implements EmailProvider {
-  protected readonly log: _alepha_logger0.Logger;
-  protected emails: EmailRecord[];
-  send(to: string, subject: string, body: string): Promise<void>;
-  /**
-   * Get all emails sent through this provider (for testing purposes).
-   */
-  getEmails(): EmailRecord[];
-  /**
-   * Clear all stored emails (for testing purposes).
-   */
-  clearEmails(): void;
-  /**
-   * Get the last email sent (for testing purposes).
-   */
-  getLastEmail(): EmailRecord | undefined;
-}
-//#endregion
-//#region src/services/TemplateService.d.ts
-/**
- * Minimal template service with Handlebars-like syntax for email templating.
- * Supports simple variable substitution with {{variableName}} syntax.
- */
-declare class TemplateService {
-  /**
-   * Compile a template string with the provided values.
-   *
-   * @param template Template string with {{variableName}} placeholders
-   * @param values Object containing values to substitute
-   * @returns Compiled template string with values substituted
-   *
-   * @example
-   * ```ts
-   * const service = new TemplateService();
-   * const result = service.compile("Hello {{name}}!", { name: "John" });
-   * // Result: "Hello John!"
-   * ```
-   */
-  compile(template: string, values: Record<string, unknown>): string;
-  /**
-   * Validate that all required template variables are provided.
-   *
-   * @param template Template string
-   * @param values Values object
-   * @returns Array of missing variable names
-   */
-  validateTemplate(template: string, values: Record<string, unknown>): string[];
-  /**
-   * Extract all variable names from a template.
-   *
-   * @param template Template string
-   * @returns Array of variable names found in the template
-   */
-  extractVariables(template: string): string[];
-}
-//#endregion
-//#region src/descriptors/$email.d.ts
-/**
- * Creates an email descriptor for sending type-safe templated emails.
- *
- * The $email descriptor provides a powerful templating system for creating and sending emails
- * with full type safety and validation. It supports multiple email providers, template variable
- * validation, and automatic HTML rendering.
- *
- * **Template Engine**
- * - Simple {{variable}} syntax for dynamic content
- * - Automatic template variable validation at runtime
- * - Support for nested object properties in templates
- * - HTML email support with rich formatting
- *
- * **Type Safety**
- * - Full TypeScript support with schema validation using TypeBox
- * - Compile-time type checking for template variables
- * - Runtime validation of email data before sending
- * - Automatic type inference from schema definitions
- *
- * **Provider Flexibility**
- * - Memory provider for development and testing
- * - Support for SMTP, SendGrid, AWS SES, and other providers
- * - Custom provider implementation for specialized services
- * - Automatic fallback and error handling
- *
- * **Template Management**
- * - Reusable email templates across your application
- * - Centralized template configuration and maintenance
- * - Template variable documentation through schemas
- * - Easy testing and preview capabilities
- *
- * **Development Experience**
- * - Clear error messages for missing template variables
- * - Comprehensive logging for debugging email delivery
- * - Memory provider captures emails for testing
- * - Template validation before sending
- *
- * @example Welcome email template
- * ```typescript
- * const welcomeEmail = $email({
- *   subject: "Welcome to {{companyName}}, {{firstName}}!",
- *   body: `
- *     <h1>Welcome {{firstName}} {{lastName}}!</h1>
- *     <p>Thank you for joining {{companyName}}.</p>
- *     <p>Your account role is: <strong>{{role}}</strong></p>
- *     <p>Get started by visiting your <a href="{{dashboardUrl}}">dashboard</a>.</p>
- *   `,
- *   schema: t.object({
- *     firstName: t.text(),
- *     lastName: t.text(),
- *     companyName: t.text(),
- *     role: t.enum(["admin", "user", "manager"]),
- *     dashboardUrl: t.text()
- *   })
- * });
- *
- * // Send with full type safety
- * await welcomeEmail.send("user@example.com", {
- *   firstName: "John",
- *   lastName: "Doe",
- *   companyName: "Acme Corp",
- *   role: "user",
- *   dashboardUrl: "https://app.acme.com/dashboard"
- * });
- * ```
- *
- * @example Order confirmation email
- * ```typescript
- * const orderConfirmation = $email({
- *   subject: "Order #{{orderNumber}} confirmed - {{totalAmount}}",
- *   body: `
- *     <h1>Order Confirmed!</h1>
- *     <p>Hi {{customerName}},</p>
- *     <p>Your order #{{orderNumber}} has been confirmed.</p>
- *     <h2>Order Details:</h2>
- *     <p><strong>Total: {{totalAmount}}</strong></p>
- *     <p>Estimated delivery: {{deliveryDate}}</p>
- *   `,
- *   schema: t.object({
- *     customerName: t.text(),
- *     orderNumber: t.text(),
- *     totalAmount: t.text(),
- *     deliveryDate: t.text()
- *   })
- * });
- * ```
- *
- * @example Development with memory provider
- * ```typescript
- * const testEmail = $email({
- *   subject: "Test: {{subject}}",
- *   body: "<p>{{message}}</p>",
- *   provider: "memory", // Captures emails for testing
- *   schema: t.object({
- *     subject: t.text(),
- *     message: t.text()
- *   })
- * });
- *
- * // In tests - emails are captured, not actually sent
- * await testEmail.send("test@example.com", {
- *   subject: "Unit Test",
- *   message: "This email was captured for testing"
- * });
- * ```
- */
-declare const $email: {
-  <T extends TSchema>(options: EmailDescriptorOptions<T>): EmailDescriptor<T>;
-  [KIND]: typeof EmailDescriptor;
 };
-interface EmailDescriptorOptions<T extends TSchema> {
-  /**
-   * Email subject template. Supports {{variableName}} syntax.
-   */
-  subject: string;
-  /**
-   * Email body template (HTML content). Supports {{variableName}} syntax.
-   */
-  body: string;
-  /**
-   * Schema defining the structure of template variables.
-   */
-  schema: T;
-  /**
-   * Optional name of the email template.
-   * @default Descriptor key
-   */
-  name?: string;
-  /**
-   * Optional description of the email template.
-   */
-  description?: string;
-  /**
-   * Email provider to use. If not provided, the default provider will be used.
-   */
-  provider?: Service<EmailProvider> | "memory";
-}
-declare class EmailDescriptor<T extends TSchema> extends Descriptor<EmailDescriptorOptions<T>> {
-  protected readonly log: _alepha_logger0.Logger;
-  protected readonly templateService: TemplateService;
-  readonly provider: EmailProvider | MemoryEmailProvider;
-  get name(): string;
-  /**
-   * Send an email using the template with the provided values.
-   *
-   * @param to Recipient email address
-   * @param values Template variable values
-   */
-  send(to: string, values: Static<T>): Promise<void>;
-  protected $provider(): EmailProvider | MemoryEmailProvider;
-}
 //#endregion
 //#region src/errors/EmailError.d.ts
 declare class EmailError extends Error {
@@ -247,7 +31,7 @@ declare class EmailError extends Error {
 interface LocalEmailProviderOptions {
   /**
    * Directory to save email files.
-   * @default "email" (relative to project root)
+   * @default "node_modules/.email" (relative to project root)
    */
   directory?: string;
 }
@@ -255,9 +39,30 @@ declare class LocalEmailProvider implements EmailProvider {
   protected readonly log: _alepha_logger0.Logger;
   protected readonly directory: string;
   constructor(options?: LocalEmailProviderOptions);
-  send(to: string, subject: string, body: string): Promise<void>;
-  protected createEmailHtml(to: string, subject: string, body: string): string;
-  protected escapeHtml(text: string): string;
+  send(options: EmailSendOptions): Promise<void>;
+  createEmailHtml(options: {
+    to: string;
+    subject: string;
+    body: string;
+  }): string;
+  escapeHtml(text: string): string;
+}
+//#endregion
+//#region src/providers/MemoryEmailProvider.d.ts
+interface EmailRecord {
+  to: string;
+  subject: string;
+  body: string;
+  sentAt: Date;
+}
+declare class MemoryEmailProvider implements EmailProvider {
+  protected readonly log: _alepha_logger0.Logger;
+  records: EmailRecord[];
+  send(options: EmailSendOptions): Promise<void>;
+  /**
+   * Get the last email sent (for testing purposes).
+   */
+  get last(): EmailRecord | undefined;
 }
 //#endregion
 //#region src/providers/NodemailerEmailProvider.d.ts
@@ -297,7 +102,7 @@ declare class NodemailerEmailProvider implements EmailProvider {
   protected fromAddress: string;
   readonly options: NodemailerEmailProviderOptions;
   constructor();
-  send(to: string, subject: string, body: string): Promise<void>;
+  send(options: EmailSendOptions): Promise<void>;
   protected createTransporter(): Transporter;
   /**
    * Verify the connection to the email server.
@@ -312,6 +117,17 @@ declare class NodemailerEmailProvider implements EmailProvider {
 }
 //#endregion
 //#region src/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    "email:sending": {
+      to: string | string[];
+      template: string;
+      variables: Record<string, unknown>;
+      provider: EmailProvider;
+      abort(): void;
+    };
+  }
+}
 /**
  * Provides email sending capabilities for Alepha applications with multiple provider backends.
  *
@@ -324,5 +140,5 @@ declare class NodemailerEmailProvider implements EmailProvider {
  */
 declare const AlephaEmail: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
-export { $email, AlephaEmail, EmailDescriptor, EmailDescriptorOptions, EmailError, EmailProvider, EmailRecord, LocalEmailProvider, LocalEmailProviderOptions, MemoryEmailProvider, NodemailerEmailProvider, NodemailerEmailProviderOptions, TemplateService };
+export { AlephaEmail, EmailError, EmailProvider, EmailRecord, EmailSendOptions, LocalEmailProvider, LocalEmailProviderOptions, MemoryEmailProvider, NodemailerEmailProvider, NodemailerEmailProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/lock.d.ts

@@ -273,7 +273,7 @@ declare const $lock: {
   <TFunc extends AsyncFn>(options: LockDescriptorOptions<TFunc>): LockDescriptor<TFunc>;
   [KIND]: typeof LockDescriptor;
 };
-interface LockDescriptorOptions<TFunc extends AsyncFn> {
+interface LockDescriptorOptions<TFunc$1 extends AsyncFn> {
   /**
    * The function to execute when the lock is successfully acquired.
    *
@@ -308,7 +308,7 @@ interface LockDescriptorOptions<TFunc extends AsyncFn> {
    * }
    * ```
    */
-  handler: TFunc;
+  handler: TFunc$1;
   /**
    * Whether the lock should wait for other instances to complete before giving up.
    *
@@ -388,7 +388,7 @@ interface LockDescriptorOptions<TFunc extends AsyncFn> {
    * });
    * ```
    */
-  name?: string | ((...args: Parameters<TFunc>) => string);
+  name?: string | ((...args: Parameters<TFunc$1>) => string);
   /**
    * Maximum duration the lock can be held before it expires automatically.
    *
@@ -474,7 +474,7 @@ interface LockDescriptorOptions<TFunc extends AsyncFn> {
    * });
    * ```
    */
-  gracePeriod?: ((...args: Parameters<TFunc>) => DurationLike | undefined) | DurationLike;
+  gracePeriod?: ((...args: Parameters<TFunc$1>) => DurationLike | undefined) | DurationLike;
 }
 declare const envSchema: _alepha_core1.TObject<{
   LOCK_PREFIX_KEY: _alepha_core1.TString;
@@ -482,7 +482,7 @@ declare const envSchema: _alepha_core1.TObject<{
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare class LockDescriptor<TFunc extends AsyncFn> extends Descriptor<LockDescriptorOptions<TFunc>> {
+declare class LockDescriptor<TFunc$1 extends AsyncFn> extends Descriptor<LockDescriptorOptions<TFunc$1>> {
   protected readonly log: _alepha_logger0.Logger;
   protected readonly provider: LockProvider;
   protected readonly env: {
@@ -496,14 +496,14 @@ declare class LockDescriptor<TFunc extends AsyncFn> extends Descriptor<LockDescr
       name: _alepha_core1.TString;
     }>;
   }>;
-  run(...args: Parameters<TFunc>): Promise<void>;
+  run(...args: Parameters<TFunc$1>): Promise<void>;
   /**
    * Set the lock for the given key.
    */
   protected lock(key: string): Promise<LockResult>;
-  protected setGracePeriod(key: string, lock: LockResult, ...args: Parameters<TFunc>): Promise<void>;
+  protected setGracePeriod(key: string, lock: LockResult, ...args: Parameters<TFunc$1>): Promise<void>;
   protected wait(key: string, maxDuration: DurationLike): Promise<void>;
-  protected key(...args: Parameters<TFunc>): string;
+  protected key(...args: Parameters<TFunc$1>): string;
   protected parse(value: string): LockResult;
 }
 interface LockResult {

package/logger.d.ts

@@ -269,7 +269,6 @@ declare module "alepha" {
   }
 }
 //# sourceMappingURL=index.d.ts.map
-
 //#endregion
 export { $logger, AlephaLogger, ConsoleColorProvider, ConsoleDestinationProvider, JsonFormatterProvider, LogDestinationProvider, LogEntry, LogFormatterProvider, Logger, LoggerDescriptorOptions, MemoryDestinationProvider, SimpleFormatterProvider, logEntrySchema };
 //# sourceMappingURL=index.d.ts.map