import { SMSTemplateEngine as ISMSTemplateEngine, SMSTemplateType, SMSTemplateVariables, SMSTemplate, SMSTemplateSource } from '../interfaces/sms-template.interface';
import { NAuthLogger } from '../utils/nauth-logger';
/**
 * SMS Template Engine
 *
 * Simple yet powerful template engine for SMS templates using text with placeholder tokens.
 * Supports {{variable}} syntax for variable injection using Handlebars-like syntax.
 *
 * Features:
 * - Simple {{variable}} placeholder syntax
 * - Built-in default templates for all SMS types
 * - Custom template registration (inline and file-based)
 * - Template validation (ensures required variables are present)
 * - Handlebars-like conditionals support
 *
 * @example
 * ```typescript
 * const engine = new SMSTemplateEngine();
 * const result = await engine.render(
 *   SMSTemplateType.VERIFICATION,
 *   { appName: 'My App', code: '123456', expiryMinutes: 5 }
 * );
 * // result.content: "My App: Your verification code is 123456. Valid for 5 minutes."
 * ```
 */
export declare class SMSTemplateEngineImpl implements ISMSTemplateEngine {
    /**
     * Storage for registered templates
     * Maps template type to template content string
     */
    private templates;
    /**
     * Base directory for resolving relative template file paths
     */
    private readonly baseDir;
    /**
     * Logger instance for error reporting
     */
    private readonly logger?;
    /**
     * Constructor
     *
     * Initializes the engine with default templates.
     *
     * @param baseDir - Base directory for resolving template file paths (default: process.cwd())
     * @param logger - Optional logger instance for error reporting
     *
     * @example
     * ```typescript
     * // Use default templates
     * const engine = new SMSTemplateEngineImpl();
     *
     * // Use custom base directory for file-based templates
     * const engine = new SMSTemplateEngineImpl('./sms-templates');
     * ```
     */
    constructor(baseDir?: string, logger?: NAuthLogger);
    /**
     * Render a template with variables
     *
     * Replaces all {{variable}} placeholders with actual values.
     * Handles missing variables gracefully (replaces with empty string).
     * Supports simple conditionals like {{#if variable}}...{{/if}}.
     *
     * @param type - Template type to render
     * @param variables - Variables to inject
     * @returns Rendered SMS template with content
     * @throws {NAuthException} If template type not found
     *
     * @example
     * ```typescript
     * const result = await engine.render(
     *   SMSTemplateType.VERIFICATION,
     *   { appName: 'My App', code: '123456', expiryMinutes: 5 }
     * );
     * ```
     */
    render(type: SMSTemplateType | string, variables: SMSTemplateVariables): Promise<SMSTemplate>;
    /**
     * Register a custom template from inline string
     *
     * Allows overriding default templates or adding new ones.
     *
     * @param type - Template type identifier
     * @param template - Template definition with inline content
     *
     * @example
     * ```typescript
     * engine.registerTemplate(SMSTemplateType.VERIFICATION, {
     *   content: '{{appName}}: Your verification code is {{code}}. Expires in {{expiryMinutes}} min.',
     * });
     * ```
     */
    registerTemplate(type: SMSTemplateType | string, template: SMSTemplate): void;
    /**
     * Register a custom template from mixed sources (strings or files)
     *
     * Flexible registration that supports both inline content and file paths.
     *
     * @param type - Template type identifier
     * @param templateSource - Template source (content or file path)
     *
     * @throws {NAuthException} If file not found or invalid source
     *
     * @example
     * ```typescript
     * // Inline content
     * await engine.registerTemplateFromSources(SMSTemplateType.VERIFICATION, {
     *   content: { content: '{{appName}}: Your code is {{code}}.' },
     * });
     *
     * // File-based
     * await engine.registerTemplateFromSources(SMSTemplateType.MFA, {
     *   content: { filePath: './sms-templates/mfa.txt.hbs' },
     * });
     * ```
     */
    registerTemplateFromSources(type: SMSTemplateType | string, templateSource: {
        content: SMSTemplateSource;
    }): Promise<void>;
    /**
     * Get all available template types
     *
     * @returns Array of registered template type identifiers
     */
    getAvailableTemplates(): string[];
    /**
     * Check if a template exists
     *
     * @param type - Template type to check
     * @returns True if template is registered
     */
    hasTemplate(type: SMSTemplateType | string): boolean;
    /**
     * Validate that a template includes required variables
     *
     * Checks if the template content includes all required placeholders.
     *
     * @param type - Template type to validate
     * @param requiredVars - Array of required variable names (without {{}})
     * @returns True if all required variables are present
     *
     * @example
     * ```typescript
     * const isValid = engine.validateTemplate(SMSTemplateType.VERIFICATION, ['code', 'expiryMinutes']);
     * ```
     */
    validateTemplate(type: SMSTemplateType | string, requiredVars: string[]): boolean;
    /**
     * Register default templates for all SMS types
     *
     * Provides sensible defaults that can be overridden by custom templates.
     *
     * @private
     */
    private registerDefaultTemplates;
    /**
     * Replace {{variable}} placeholders with values
     *
     * Handles missing variables gracefully (replaces with empty string).
     * Supports simple conditionals like {{#if variable}}...{{/if}}.
     *
     * @param template - Template string with {{placeholders}}
     * @param variables - Variables to inject
     * @returns Template with variables replaced
     * @private
     */
    private replaceVariables;
}
//# sourceMappingURL=sms-template.engine.d.ts.map