@bernierllc/email-sendgrid-plugin 1.0.1

package/dist/api/rate-limiter.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleRateLimiter = void 0;
+const errors_1 = require("./errors");
+class SimpleRateLimiter {
+    constructor(config) {
+        this.requestTimestamps = [];
+        this.maxRequestsPerSecond = config.maxRequestsPerSecond;
+        this.maxRequestsPerMinute = config.maxRequestsPerMinute;
+    }
+    async acquire() {
+        const now = Date.now();
+        // Clean up old timestamps
+        this.requestTimestamps = this.requestTimestamps.filter(timestamp => now - timestamp < 60000 // Keep last minute
+        );
+        // Check per-second limit
+        const lastSecond = this.requestTimestamps.filter(timestamp => now - timestamp < 1000);
+        if (lastSecond.length >= this.maxRequestsPerSecond) {
+            const waitTime = 1000 - (now - lastSecond[0]);
+            await this.sleep(waitTime);
+            return this.acquire();
+        }
+        // Check per-minute limit
+        if (this.requestTimestamps.length >= this.maxRequestsPerMinute) {
+            const waitTime = 60000 - (now - this.requestTimestamps[0]);
+            if (waitTime > 5000) {
+                throw new errors_1.RateLimitError(`Rate limit exceeded, would need to wait ${Math.ceil(waitTime / 1000)}s`);
+            }
+            await this.sleep(waitTime);
+            return this.acquire();
+        }
+        // Add timestamp and proceed
+        this.requestTimestamps.push(now);
+    }
+    release() {
+        // No-op for simple implementation
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, Math.max(0, ms)));
+    }
+    getRemainingCapacity() {
+        const now = Date.now();
+        const lastSecond = this.requestTimestamps.filter(timestamp => now - timestamp < 1000).length;
+        const lastMinute = this.requestTimestamps.length;
+        return {
+            perSecond: Math.max(0, this.maxRequestsPerSecond - lastSecond),
+            perMinute: Math.max(0, this.maxRequestsPerMinute - lastMinute)
+        };
+    }
+}
+exports.SimpleRateLimiter = SimpleRateLimiter;

package/dist/api/sendgrid-client.d.ts

@@ -0,0 +1,21 @@
+import { ApiRequestOptions, ApiResponse } from '../types/config-types';
+import { SimpleRateLimiter } from './rate-limiter';
+export interface SendGridClientConfig {
+    apiKey: string;
+    rateLimiter?: SimpleRateLimiter;
+    logger?: {
+        debug: (message: string) => void;
+        error: (message: string) => void;
+        info: (message: string) => void;
+    };
+}
+export declare class SendGridClient {
+    private readonly apiKey;
+    private readonly rateLimiter?;
+    private readonly logger?;
+    private readonly baseUrl;
+    constructor(config: SendGridClientConfig);
+    request(endpoint: string, options: ApiRequestOptions): Promise<ApiResponse>;
+    isSuccessResponse(response: ApiResponse): boolean;
+    parseResponseBody<T>(response: ApiResponse): T;
+}

package/dist/api/sendgrid-client.js

@@ -0,0 +1,67 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendGridClient = void 0;
+const errors_1 = require("./errors");
+class SendGridClient {
+    constructor(config) {
+        this.baseUrl = 'https://api.sendgrid.com/v3';
+        this.apiKey = config.apiKey;
+        this.rateLimiter = config.rateLimiter;
+        this.logger = config.logger;
+    }
+    async request(endpoint, options) {
+        // Apply rate limiting if configured
+        if (this.rateLimiter) {
+            await this.rateLimiter.acquire();
+        }
+        try {
+            const url = `${this.baseUrl}${endpoint}`;
+            const response = await fetch(url, {
+                method: options.method,
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                    ...options.headers
+                },
+                body: options.body
+            });
+            const body = await response.text();
+            // Log all API calls for audit trail
+            this.logger?.debug(`SendGrid API ${options.method} ${endpoint}: ${response.status}`);
+            return {
+                statusCode: response.status,
+                headers: Object.fromEntries(response.headers.entries()),
+                body
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger?.error(`SendGrid API error: ${errorMessage}`);
+            throw new errors_1.SendGridApiError(`API request failed: ${errorMessage}`, undefined, error);
+        }
+        finally {
+            if (this.rateLimiter) {
+                this.rateLimiter.release();
+            }
+        }
+    }
+    isSuccessResponse(response) {
+        return response.statusCode >= 200 && response.statusCode < 300;
+    }
+    parseResponseBody(response) {
+        try {
+            return JSON.parse(response.body);
+        }
+        catch (error) {
+            throw new errors_1.SendGridApiError('Failed to parse response body', response.statusCode, response.body);
+        }
+    }
+}
+exports.SendGridClient = SendGridClient;

package/dist/converters/sender-converter.d.ts

@@ -0,0 +1,6 @@
+import { VerifiedSender, SendGridVerifiedSenderData } from '../types/sendgrid-types';
+export declare class SenderConverter {
+    convertToVerifiedSender(sendgridData: SendGridVerifiedSenderData): VerifiedSender;
+    extractDomain(email: string): string;
+    isDomainMatch(domain1: string, domain2: string): boolean;
+}

package/dist/converters/sender-converter.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderConverter = void 0;
+class SenderConverter {
+    convertToVerifiedSender(sendgridData) {
+        const domain = this.extractDomain(sendgridData.from_email);
+        return {
+            id: sendgridData.id.toString(),
+            email: sendgridData.from_email,
+            name: sendgridData.from_name || sendgridData.nickname,
+            isVerified: sendgridData.verified,
+            domain,
+            verificationStatus: sendgridData.verified ? 'verified' : 'pending',
+            createdAt: new Date(), // SendGrid doesn't provide creation date
+            lastVerifiedAt: sendgridData.verified ? new Date() : undefined
+        };
+    }
+    extractDomain(email) {
+        return email.split('@')[1]?.toLowerCase() || '';
+    }
+    isDomainMatch(domain1, domain2) {
+        // Exact match
+        if (domain1 === domain2)
+            return true;
+        // Subdomain match (e.g., app.example.com matches example.com)
+        if (domain1.endsWith(`.${domain2}`))
+            return true;
+        if (domain2.endsWith(`.${domain1}`))
+            return true;
+        return false;
+    }
+}
+exports.SenderConverter = SenderConverter;

package/dist/converters/template-converter.d.ts

@@ -0,0 +1,11 @@
+import { SendGridTemplateData, SendGridTemplateVersion } from '../types/sendgrid-types';
+import { ProviderTemplate, Template } from '../types/plugin-types';
+import { PrefixEnforcer } from '../safety/prefix-enforcer';
+export declare class TemplateConverter {
+    private readonly prefixEnforcer;
+    constructor(prefixEnforcer: PrefixEnforcer);
+    convertToProviderTemplate(sendgridData: SendGridTemplateData, activeVersion?: SendGridTemplateVersion): ProviderTemplate;
+    convertToLocalTemplate(sendgridData: SendGridTemplateData, localId: string, activeVersion?: SendGridTemplateVersion): Template;
+    extractVariables(content: string): string[];
+    private findActiveVersion;
+}

package/dist/converters/template-converter.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateConverter = void 0;
+class TemplateConverter {
+    constructor(prefixEnforcer) {
+        this.prefixEnforcer = prefixEnforcer;
+    }
+    convertToProviderTemplate(sendgridData, activeVersion) {
+        // Find active version if not provided
+        const version = activeVersion || this.findActiveVersion(sendgridData.versions || []);
+        return {
+            id: sendgridData.id,
+            name: this.prefixEnforcer.stripPrefix(sendgridData.name),
+            subject: version?.subject || '',
+            htmlContent: version?.html_content || '',
+            textContent: version?.plain_content,
+            version: version?.name || '1.0.0',
+            active: version?.active === 1,
+            createdAt: new Date(sendgridData.updated_at),
+            updatedAt: new Date(sendgridData.updated_at)
+        };
+    }
+    convertToLocalTemplate(sendgridData, localId, activeVersion) {
+        const providerTemplate = this.convertToProviderTemplate(sendgridData, activeVersion);
+        return {
+            id: localId,
+            name: providerTemplate.name,
+            subject: providerTemplate.subject,
+            htmlContent: providerTemplate.htmlContent,
+            textContent: providerTemplate.textContent,
+            category: 'synced',
+            tags: ['sendgrid', 'synced'],
+            version: providerTemplate.version,
+            isActive: providerTemplate.active,
+            requiredVariables: [],
+            providerTemplateIds: {
+                sendgrid: sendgridData.id
+            },
+            lastSyncedAt: {
+                sendgrid: new Date()
+            },
+            syncStatus: {
+                sendgrid: 'success'
+            },
+            createdAt: providerTemplate.createdAt,
+            updatedAt: providerTemplate.updatedAt,
+            createdBy: 'sendgrid-sync',
+            lastModifiedBy: 'sendgrid-sync'
+        };
+    }
+    extractVariables(content) {
+        // Extract Handlebars-style variables: {{variableName}}
+        const regex = /\{\{([^}]+)\}\}/g;
+        const matches = content.matchAll(regex);
+        const variables = new Set();
+        for (const match of matches) {
+            const variable = match[1].trim();
+            // Filter out Handlebars helpers
+            if (!variable.startsWith('#') && !variable.startsWith('/')) {
+                variables.add(variable);
+            }
+        }
+        return Array.from(variables);
+    }
+    findActiveVersion(versions) {
+        return versions.find(v => v.active === 1) || versions[0];
+    }
+}
+exports.TemplateConverter = TemplateConverter;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { SendGridTemplatePlugin, TemplateProviderPlugin } from './plugin/sendgrid-plugin';
+export { TemplateManager } from './plugin/template-manager';
+export { SenderManager } from './plugin/sender-manager';
+export { SyncManager } from './plugin/sync-manager';
+export { SendGridClient } from './api/sendgrid-client';
+export { SimpleRateLimiter } from './api/rate-limiter';
+export { OwnershipValidator, SafetyMode } from './safety/ownership-validator';
+export { PrefixEnforcer } from './safety/prefix-enforcer';
+export { TemplateConverter } from './converters/template-converter';
+export { SenderConverter } from './converters/sender-converter';
+export { SendGridApiError, TemplateNotFoundError, UnauthorizedTemplateAccessError, TemplateConflictError, RateLimitError } from './api/errors';
+export type { SendGridPluginConfig, ApiRequestOptions, ApiResponse } from './types/config-types';
+export type { PluginConfig, ProviderCapability, Template, ProviderTemplate, TemplateVersion, SyncResult, ValidationResult, DateRange, TemplateAnalytics, FeatureConfig } from './types/plugin-types';
+export type { VerifiedSender, SenderValidationResult, SendGridTemplateData, SendGridTemplateVersion, SendGridVerifiedSenderData } from './types/sendgrid-types';

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitError = exports.TemplateConflictError = exports.UnauthorizedTemplateAccessError = exports.TemplateNotFoundError = exports.SendGridApiError = exports.SenderConverter = exports.TemplateConverter = exports.PrefixEnforcer = exports.OwnershipValidator = exports.SimpleRateLimiter = exports.SendGridClient = exports.SyncManager = exports.SenderManager = exports.TemplateManager = exports.SendGridTemplatePlugin = void 0;
+// Main plugin class
+var sendgrid_plugin_1 = require("./plugin/sendgrid-plugin");
+Object.defineProperty(exports, "SendGridTemplatePlugin", { enumerable: true, get: function () { return sendgrid_plugin_1.SendGridTemplatePlugin; } });
+// Plugin components
+var template_manager_1 = require("./plugin/template-manager");
+Object.defineProperty(exports, "TemplateManager", { enumerable: true, get: function () { return template_manager_1.TemplateManager; } });
+var sender_manager_1 = require("./plugin/sender-manager");
+Object.defineProperty(exports, "SenderManager", { enumerable: true, get: function () { return sender_manager_1.SenderManager; } });
+var sync_manager_1 = require("./plugin/sync-manager");
+Object.defineProperty(exports, "SyncManager", { enumerable: true, get: function () { return sync_manager_1.SyncManager; } });
+// API components
+var sendgrid_client_1 = require("./api/sendgrid-client");
+Object.defineProperty(exports, "SendGridClient", { enumerable: true, get: function () { return sendgrid_client_1.SendGridClient; } });
+var rate_limiter_1 = require("./api/rate-limiter");
+Object.defineProperty(exports, "SimpleRateLimiter", { enumerable: true, get: function () { return rate_limiter_1.SimpleRateLimiter; } });
+// Safety components
+var ownership_validator_1 = require("./safety/ownership-validator");
+Object.defineProperty(exports, "OwnershipValidator", { enumerable: true, get: function () { return ownership_validator_1.OwnershipValidator; } });
+var prefix_enforcer_1 = require("./safety/prefix-enforcer");
+Object.defineProperty(exports, "PrefixEnforcer", { enumerable: true, get: function () { return prefix_enforcer_1.PrefixEnforcer; } });
+// Converters
+var template_converter_1 = require("./converters/template-converter");
+Object.defineProperty(exports, "TemplateConverter", { enumerable: true, get: function () { return template_converter_1.TemplateConverter; } });
+var sender_converter_1 = require("./converters/sender-converter");
+Object.defineProperty(exports, "SenderConverter", { enumerable: true, get: function () { return sender_converter_1.SenderConverter; } });
+// Errors
+var errors_1 = require("./api/errors");
+Object.defineProperty(exports, "SendGridApiError", { enumerable: true, get: function () { return errors_1.SendGridApiError; } });
+Object.defineProperty(exports, "TemplateNotFoundError", { enumerable: true, get: function () { return errors_1.TemplateNotFoundError; } });
+Object.defineProperty(exports, "UnauthorizedTemplateAccessError", { enumerable: true, get: function () { return errors_1.UnauthorizedTemplateAccessError; } });
+Object.defineProperty(exports, "TemplateConflictError", { enumerable: true, get: function () { return errors_1.TemplateConflictError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });

package/dist/plugin/sender-manager.d.ts

@@ -0,0 +1,20 @@
+import { SendGridClient } from '../api/sendgrid-client';
+import { SenderConverter } from '../converters/sender-converter';
+import { VerifiedSender, SenderValidationResult } from '../types/sendgrid-types';
+export declare class SenderManager {
+    private readonly client;
+    private readonly converter;
+    private readonly logger?;
+    private sendersCache?;
+    private cacheTimestamp?;
+    private readonly cacheTTL;
+    constructor(client: SendGridClient, converter: SenderConverter, logger?: {
+        info: (message: string) => void;
+        debug: (message: string) => void;
+    } | undefined);
+    getVerifiedSenders(useCache?: boolean): Promise<VerifiedSender[]>;
+    validateSender(email: string): Promise<SenderValidationResult>;
+    selectBestSender(fromEmail: string): Promise<VerifiedSender | null>;
+    clearCache(): void;
+    private getSenderSuggestions;
+}

package/dist/plugin/sender-manager.js

@@ -0,0 +1,124 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderManager = void 0;
+const errors_1 = require("../api/errors");
+class SenderManager {
+    constructor(client, converter, logger) {
+        this.client = client;
+        this.converter = converter;
+        this.logger = logger;
+        this.cacheTTL = 300000; // 5 minutes
+    }
+    async getVerifiedSenders(useCache = true) {
+        // Return cached data if valid
+        if (useCache &&
+            this.sendersCache &&
+            this.cacheTimestamp &&
+            Date.now() - this.cacheTimestamp < this.cacheTTL) {
+            this.logger?.debug('Returning cached verified senders');
+            return this.sendersCache;
+        }
+        const response = await this.client.request('/verified_senders', {
+            method: 'GET'
+        });
+        if (!this.client.isSuccessResponse(response)) {
+            throw new errors_1.SendGridApiError('Failed to fetch verified senders', response.statusCode, response.body);
+        }
+        const data = this.client.parseResponseBody(response);
+        const senders = data.results.map(sender => this.converter.convertToVerifiedSender(sender));
+        // Update cache
+        this.sendersCache = senders;
+        this.cacheTimestamp = Date.now();
+        this.logger?.info(`Fetched ${senders.length} verified senders from SendGrid`);
+        return senders;
+    }
+    async validateSender(email) {
+        const verifiedSenders = await this.getVerifiedSenders();
+        const emailDomain = this.converter.extractDomain(email);
+        // Check for exact match
+        const exactMatch = verifiedSenders.find(sender => sender.email.toLowerCase() === email.toLowerCase() && sender.isVerified);
+        if (exactMatch) {
+            return {
+                isValid: true,
+                verifiedSender: exactMatch,
+                domain: emailDomain,
+                domainMatches: [exactMatch],
+                errors: [],
+                suggestions: []
+            };
+        }
+        // Check for domain matches
+        const domainMatches = verifiedSenders.filter(sender => {
+            const senderDomain = this.converter.extractDomain(sender.email);
+            return this.converter.isDomainMatch(emailDomain, senderDomain) && sender.isVerified;
+        });
+        if (domainMatches.length > 0) {
+            return {
+                isValid: true,
+                domain: emailDomain,
+                domainMatches,
+                errors: [],
+                suggestions: domainMatches.map(sender => sender.email)
+            };
+        }
+        // No matches found
+        return {
+            isValid: false,
+            domain: emailDomain,
+            domainMatches: [],
+            errors: [`No verified sender found for email ${email} or domain ${emailDomain}`],
+            suggestions: this.getSenderSuggestions(email, verifiedSenders)
+        };
+    }
+    async selectBestSender(fromEmail) {
+        const validation = await this.validateSender(fromEmail);
+        if (!validation.isValid || validation.domainMatches.length === 0) {
+            return null;
+        }
+        // Prefer exact match
+        if (validation.verifiedSender) {
+            return validation.verifiedSender;
+        }
+        // Fall back to best domain match
+        // Priority: most recently verified, then alphabetical
+        return validation.domainMatches.sort((a, b) => {
+            if (a.lastVerifiedAt && b.lastVerifiedAt) {
+                return b.lastVerifiedAt.getTime() - a.lastVerifiedAt.getTime();
+            }
+            if (a.lastVerifiedAt && !b.lastVerifiedAt)
+                return -1;
+            if (!a.lastVerifiedAt && b.lastVerifiedAt)
+                return 1;
+            return a.email.localeCompare(b.email);
+        })[0];
+    }
+    clearCache() {
+        this.sendersCache = undefined;
+        this.cacheTimestamp = undefined;
+        this.logger?.debug('Cleared verified senders cache');
+    }
+    getSenderSuggestions(email, senders) {
+        const emailDomain = this.converter.extractDomain(email);
+        // Find senders with similar domains
+        const suggestions = [];
+        for (const sender of senders) {
+            if (!sender.isVerified)
+                continue;
+            const senderDomain = this.converter.extractDomain(sender.email);
+            // Check for partial domain matches
+            if (emailDomain.includes(senderDomain) ||
+                senderDomain.includes(emailDomain)) {
+                suggestions.push(sender.email);
+            }
+        }
+        return suggestions.slice(0, 5); // Limit to 5 suggestions
+    }
+}
+exports.SenderManager = SenderManager;

package/dist/plugin/sendgrid-plugin.d.ts

@@ -0,0 +1,60 @@
+import { SendGridPluginConfig } from '../types/config-types';
+import { PluginConfig, ProviderCapability, Template, ProviderTemplate, TemplateVersion, SyncResult, ValidationResult, DateRange, TemplateAnalytics, FeatureConfig } from '../types/plugin-types';
+import { VerifiedSender, SenderValidationResult } from '../types/sendgrid-types';
+export interface TemplateProviderPlugin {
+    readonly name: string;
+    readonly version: string;
+    readonly providerId: string;
+    initialize(config: PluginConfig): Promise<void>;
+    destroy(): Promise<void>;
+    createTemplate(template: Template): Promise<string>;
+    updateTemplate(providerTemplateId: string, template: Template): Promise<void>;
+    deleteTemplate(providerTemplateId: string): Promise<void>;
+    getTemplate(providerTemplateId: string): Promise<ProviderTemplate>;
+    listTemplates(): Promise<ProviderTemplate[]>;
+    syncToProvider(template: Template): Promise<SyncResult>;
+    syncFromProvider(providerTemplateId: string): Promise<Template>;
+    getCapabilities(): ProviderCapability[];
+    supportsFeature(feature: string): boolean;
+    getFeatureConfig(feature: string): FeatureConfig | null;
+}
+export declare class SendGridTemplatePlugin implements TemplateProviderPlugin {
+    readonly name = "sendgrid-templates";
+    readonly version = "1.0.0";
+    readonly providerId = "sendgrid";
+    private client;
+    private rateLimiter?;
+    private ownershipValidator;
+    private prefixEnforcer;
+    private templateConverter;
+    private senderConverter;
+    private templateManager;
+    private senderManager;
+    private syncManager;
+    private readonly config;
+    private readonly logger?;
+    private initialized;
+    constructor(config: SendGridPluginConfig);
+    initialize(__pluginConfig: PluginConfig): Promise<void>;
+    destroy(): Promise<void>;
+    createTemplate(template: Template): Promise<string>;
+    updateTemplate(providerTemplateId: string, template: Template): Promise<void>;
+    deleteTemplate(providerTemplateId: string): Promise<void>;
+    getTemplate(providerTemplateId: string): Promise<ProviderTemplate>;
+    listTemplates(): Promise<ProviderTemplate[]>;
+    syncToProvider(template: Template): Promise<SyncResult>;
+    syncFromProvider(providerTemplateId: string): Promise<Template>;
+    getVerifiedSenders(): Promise<VerifiedSender[]>;
+    validateSender(email: string): Promise<SenderValidationResult>;
+    selectBestSender(email: string): Promise<VerifiedSender | null>;
+    createTemplateVersion(templateId: string, version: TemplateVersion): Promise<string>;
+    activateTemplateVersion(templateId: string, versionId: string): Promise<void>;
+    getTemplateAnalytics(__templateId: string, __dateRange: DateRange): Promise<TemplateAnalytics>;
+    batchSyncTemplates(templates: Template[]): Promise<SyncResult[]>;
+    getCapabilities(): ProviderCapability[];
+    supportsFeature(feature: string): boolean;
+    getFeatureConfig(feature: string): FeatureConfig | null;
+    validateRoute(__route: unknown): ValidationResult;
+    private loadExistingTemplates;
+    private ensureInitialized;
+}