@metigan/angular 1.0.2 → 1.0.3

package/dist/fesm2022/metigan-angular.mjs

@@ -1,1241 +0,0 @@
-import * as i0 from '@angular/core';
-import { Injectable, Optional, Inject, NgModule } from '@angular/core';
-import { timer, throwError, Observable } from 'rxjs';
-import { map, retryWhen, mergeMap, catchError } from 'rxjs/operators';
-import * as i1 from '@angular/common/http';
-import { HttpParams, HttpClientModule } from '@angular/common/http';
-
-/**
- * Custom error classes for Metigan SDK
- */
-/**
- * Base error class for all Metigan errors
- */
-class MetiganError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'MetiganError';
-        Object.setPrototypeOf(this, MetiganError.prototype);
-    }
-}
-/**
- * Validation error - thrown when input validation fails
- */
-class ValidationError extends MetiganError {
-    field;
-    constructor(message, field) {
-        super(message);
-        this.name = 'ValidationError';
-        this.field = field;
-        Object.setPrototypeOf(this, ValidationError.prototype);
-    }
-}
-/**
- * API error - thrown when API request fails
- */
-class ApiError extends MetiganError {
-    statusCode;
-    status;
-    constructor(message, statusCode) {
-        super(message);
-        this.name = 'ApiError';
-        this.statusCode = statusCode || statusCode;
-        this.status = statusCode;
-        Object.setPrototypeOf(this, ApiError.prototype);
-    }
-}
-
-/**
- * Metigan Library Configuration
- * Central configuration file for all modules
- */
-/**
- * Default API URL for Metigan services
- * All API calls are routed through this single endpoint
- *
- * Can be overridden with METIGAN_API_URL environment variable for testing
- */
-const API_URL = (typeof process !== 'undefined' && process.env?.['METIGAN_API_URL'])
-    || 'https://api.metigan.com';
-/**
- * SDK Version
- */
-const SDK_VERSION = '1.0.0';
-/**
- * Default timeout for API requests (in milliseconds)
- */
-const DEFAULT_TIMEOUT = 30000;
-/**
- * Default retry configuration
- */
-const DEFAULT_RETRY_COUNT = 3;
-const DEFAULT_RETRY_DELAY = 1000;
-/**
- * Maximum file size for attachments (7MB)
- */
-const MAX_FILE_SIZE = 7 * 1024 * 1024;
-
-/**
- * HTTP Client Service for Metigan SDK
- * Wraps Angular HttpClient with retry logic and error handling
- */
-class MetiganHttpClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Make GET request with retry logic
-     */
-    get(url, options, retryCount = 3, retryDelay = 1000) {
-        const opts = this.buildOptions(options);
-        return this.http.get(url, opts).pipe(map((response) => response), retryWhen(errors => errors.pipe(mergeMap((error, index) => {
-            if (index < retryCount && this.shouldRetry(error)) {
-                return timer(retryDelay * (index + 1));
-            }
-            return throwError(() => error);
-        }))), catchError(this.handleError));
-    }
-    /**
-     * Make POST request with retry logic
-     */
-    post(url, body, options, retryCount = 3, retryDelay = 1000) {
-        const opts = this.buildOptions(options);
-        return this.http.post(url, body, opts).pipe(map((response) => response), retryWhen(errors => errors.pipe(mergeMap((error, index) => {
-            if (index < retryCount && this.shouldRetry(error)) {
-                return timer(retryDelay * (index + 1));
-            }
-            return throwError(() => error);
-        }))), catchError(this.handleError));
-    }
-    /**
-     * Make PUT request with retry logic
-     */
-    put(url, body, options, retryCount = 3, retryDelay = 1000) {
-        const opts = this.buildOptions(options);
-        return this.http.put(url, body, opts).pipe(map((response) => response), retryWhen(errors => errors.pipe(mergeMap((error, index) => {
-            if (index < retryCount && this.shouldRetry(error)) {
-                return timer(retryDelay * (index + 1));
-            }
-            return throwError(() => error);
-        }))), catchError(this.handleError));
-    }
-    /**
-     * Make DELETE request with retry logic
-     */
-    delete(url, options, retryCount = 3, retryDelay = 1000) {
-        const opts = this.buildOptions(options);
-        return this.http.delete(url, opts).pipe(map((response) => response), retryWhen(errors => errors.pipe(mergeMap((error, index) => {
-            if (index < retryCount && this.shouldRetry(error)) {
-                return timer(retryDelay * (index + 1));
-            }
-            return throwError(() => error);
-        }))), catchError(this.handleError));
-    }
-    /**
-     * Build HTTP options with timeout
-     */
-    buildOptions(options) {
-        const opts = {
-            observe: 'body'
-        };
-        if (options?.headers) {
-            opts.headers = options.headers;
-        }
-        if (options?.params) {
-            opts.params = options.params;
-        }
-        // Angular HttpClient doesn't support timeout directly
-        // Timeout should be handled at the interceptor level if needed
-        return opts;
-    }
-    /**
-     * Determine if error should trigger retry
-     */
-    shouldRetry(error) {
-        // Retry on server errors (5xx) or network errors
-        return error.status >= 500 || error.status === 0 || !error.status;
-    }
-    /**
-     * Handle HTTP errors
-     */
-    handleError = (error) => {
-        if (error.error instanceof ErrorEvent) {
-            // Client-side error
-            return throwError(() => new MetiganError(`Network error: ${error.error.message}`));
-        }
-        else {
-            // Server-side error
-            const message = error.error?.message || error.error?.error || `Request failed with status ${error.status}`;
-            return throwError(() => new ApiError(message, error.status));
-        }
-    };
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganHttpClient, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganHttpClient, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganHttpClient, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-/**
- * Metigan Email Service
- * Service for sending emails through the Metigan API
- */
-class MetiganEmailService {
-    http;
-    apiKey = '';
-    apiUrl = API_URL;
-    timeout = DEFAULT_TIMEOUT;
-    retryCount = DEFAULT_RETRY_COUNT;
-    retryDelay = DEFAULT_RETRY_DELAY;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Initialize the service with API key and options
-     */
-    initialize(apiKey, options) {
-        if (!apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        this.apiKey = apiKey;
-        this.apiUrl = options?.apiUrl || API_URL;
-        this.timeout = options?.timeout || DEFAULT_TIMEOUT;
-        this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
-        this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
-    }
-    /**
-     * Validate email address format
-     */
-    validateEmail(email) {
-        if (!email || typeof email !== 'string')
-            return false;
-        const parts = email.split('@');
-        if (parts.length !== 2)
-            return false;
-        if (parts[0].length === 0)
-            return false;
-        const domainParts = parts[1].split('.');
-        if (domainParts.length < 2)
-            return false;
-        if (domainParts.some(part => part.length === 0))
-            return false;
-        return true;
-    }
-    /**
-     * Extract email address from "Name <email>" format
-     */
-    extractEmailAddress(from) {
-        if (!from)
-            return '';
-        const angleMatch = from.match(/<([^>]+)>/);
-        if (angleMatch) {
-            return angleMatch[1].trim();
-        }
-        return from.trim();
-    }
-    /**
-     * Validate email options
-     */
-    validateOptions(options) {
-        if (!options.from) {
-            throw new ValidationError('Sender email (from) is required');
-        }
-        if (!options.recipients || !Array.isArray(options.recipients) || options.recipients.length === 0) {
-            throw new ValidationError('Recipients must be a non-empty array');
-        }
-        if (!options.subject) {
-            throw new ValidationError('Subject is required');
-        }
-        if (!options.content && !options.templateId) {
-            throw new ValidationError('Either content or templateId is required');
-        }
-        const fromEmail = this.extractEmailAddress(options.from);
-        if (!this.validateEmail(fromEmail)) {
-            throw new ValidationError(`Invalid sender email format: ${fromEmail}`);
-        }
-        for (const recipient of options.recipients) {
-            const recipientEmail = this.extractEmailAddress(recipient);
-            if (!this.validateEmail(recipientEmail)) {
-                throw new ValidationError(`Invalid recipient email format: ${recipientEmail}`);
-            }
-        }
-        if (options.cc) {
-            for (const cc of options.cc) {
-                const ccEmail = this.extractEmailAddress(cc);
-                if (!this.validateEmail(ccEmail)) {
-                    throw new ValidationError(`Invalid CC email format: ${ccEmail}`);
-                }
-            }
-        }
-        if (options.bcc) {
-            for (const bcc of options.bcc) {
-                const bccEmail = this.extractEmailAddress(bcc);
-                if (!this.validateEmail(bccEmail)) {
-                    throw new ValidationError(`Invalid BCC email format: ${bccEmail}`);
-                }
-            }
-        }
-        if (options.replyTo) {
-            const replyToEmail = this.extractEmailAddress(options.replyTo);
-            if (!this.validateEmail(replyToEmail)) {
-                throw new ValidationError(`Invalid reply-to email format: ${replyToEmail}`);
-            }
-        }
-    }
-    /**
-     * Process attachments for FormData
-     */
-    async processAttachments(attachments) {
-        const formData = new FormData();
-        for (const file of attachments) {
-            if (file instanceof File) {
-                if (file.size > MAX_FILE_SIZE) {
-                    throw new MetiganError(`File ${file.name} exceeds the maximum size of 7MB`);
-                }
-                formData.append('files', file);
-            }
-            else {
-                const attachment = file;
-                // Convert content to Blob
-                let blob;
-                if (attachment.content instanceof ArrayBuffer) {
-                    blob = new Blob([attachment.content], { type: attachment.contentType });
-                }
-                else if (attachment.content instanceof Uint8Array) {
-                    blob = new Blob([attachment.content], { type: attachment.contentType });
-                }
-                else if (typeof attachment.content === 'string') {
-                    // Base64 string
-                    const byteCharacters = atob(attachment.content);
-                    const byteNumbers = new Array(byteCharacters.length);
-                    for (let i = 0; i < byteCharacters.length; i++) {
-                        byteNumbers[i] = byteCharacters.charCodeAt(i);
-                    }
-                    const byteArray = new Uint8Array(byteNumbers);
-                    blob = new Blob([byteArray], { type: attachment.contentType });
-                }
-                else {
-                    throw new MetiganError('Invalid attachment content type');
-                }
-                if (blob.size > MAX_FILE_SIZE) {
-                    throw new MetiganError(`File ${attachment.filename} exceeds the maximum size of 7MB`);
-                }
-                const fileObj = new File([blob], attachment.filename, { type: attachment.contentType });
-                formData.append('files', fileObj);
-            }
-        }
-        return formData;
-    }
-    /**
-     * Send an email
-     */
-    sendEmail(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        try {
-            this.validateOptions(options);
-        }
-        catch (error) {
-            return throwError(() => error);
-        }
-        const headers = {
-            'x-api-key': this.apiKey,
-            'User-Agent': 'AngularSDK/1.0'
-        };
-        // If attachments, use FormData
-        if (options.attachments && options.attachments.length > 0) {
-            return new Observable(observer => {
-                this.processAttachments(options.attachments).then(formData => {
-                    formData.append('from', options.from);
-                    formData.append('recipients', JSON.stringify(options.recipients));
-                    formData.append('subject', options.subject);
-                    if (options.templateId) {
-                        formData.append('useTemplate', 'true');
-                        formData.append('templateId', options.templateId);
-                    }
-                    else if (options.content) {
-                        formData.append('content', options.content);
-                    }
-                    if (options.cc && options.cc.length > 0) {
-                        formData.append('cc', JSON.stringify(options.cc));
-                    }
-                    if (options.bcc && options.bcc.length > 0) {
-                        formData.append('bcc', JSON.stringify(options.bcc));
-                    }
-                    if (options.replyTo) {
-                        formData.append('replyTo', options.replyTo);
-                    }
-                    const httpOptions = {
-                        headers: headers
-                    };
-                    this.http.post(`${this.apiUrl}/api/email/send`, formData, httpOptions, this.retryCount, this.retryDelay)
-                        .pipe(map(response => {
-                        if ('success' in response && response.success) {
-                            return response;
-                        }
-                        else {
-                            throw new MetiganError(response.message || 'Failed to send email');
-                        }
-                    }))
-                        .subscribe({
-                        next: (response) => observer.next(response),
-                        error: (error) => observer.error(error),
-                        complete: () => observer.complete()
-                    });
-                }).catch(error => observer.error(error));
-            });
-        }
-        else {
-            // No attachments, use JSON
-            const body = {
-                from: options.from,
-                recipients: options.recipients,
-                subject: options.subject
-            };
-            if (options.templateId) {
-                body.useTemplate = 'true';
-                body.templateId = options.templateId;
-            }
-            else if (options.content) {
-                body.content = options.content;
-            }
-            if (options.cc && options.cc.length > 0) {
-                body.cc = options.cc;
-            }
-            if (options.bcc && options.bcc.length > 0) {
-                body.bcc = options.bcc;
-            }
-            if (options.replyTo) {
-                body.replyTo = options.replyTo;
-            }
-            const httpOptions = {
-                headers: {
-                    ...headers,
-                    'Content-Type': 'application/json'
-                }
-            };
-            return this.http.post(`${this.apiUrl}/api/email/send`, body, httpOptions, this.retryCount, this.retryDelay)
-                .pipe(map(response => {
-                if ('success' in response && response.success) {
-                    return response;
-                }
-                else {
-                    throw new MetiganError(response.message || 'Failed to send email');
-                }
-            }));
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganEmailService, deps: [{ token: MetiganHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganEmailService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganEmailService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganHttpClient }] });
-
-/**
- * Metigan Forms Service
- * Service for form management and submissions
- */
-class MetiganFormsService {
-    http;
-    apiKey = '';
-    apiUrl = API_URL;
-    timeout = DEFAULT_TIMEOUT;
-    retryCount = DEFAULT_RETRY_COUNT;
-    retryDelay = DEFAULT_RETRY_DELAY;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Initialize the service with API key and options
-     */
-    initialize(apiKey, options) {
-        if (!apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        this.apiKey = apiKey;
-        this.apiUrl = options?.apiUrl || API_URL;
-        this.timeout = options?.timeout || DEFAULT_TIMEOUT;
-        this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
-        this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
-    }
-    /**
-     * Get default headers
-     */
-    getHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            'User-Agent': 'AngularSDK/1.0'
-        };
-    }
-    /**
-     * Submit form data
-     */
-    submit(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!options.formId) {
-            return throwError(() => new ValidationError('Form ID is required'));
-        }
-        if (!options.data || Object.keys(options.data).length === 0) {
-            return throwError(() => new ValidationError('Submission data is required'));
-        }
-        const body = {
-            formId: options.formId,
-            data: options.data
-        };
-        return this.http.post(`${this.apiUrl}/api/submissions`, body, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get form by ID or slug
-     */
-    getForm(formIdOrSlug) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!formIdOrSlug) {
-            return throwError(() => new ValidationError('Form ID or slug is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/forms/${formIdOrSlug}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get public form by slug
-     */
-    getPublicForm(slug) {
-        if (!slug) {
-            return throwError(() => new ValidationError('Form slug is required'));
-        }
-        // Public forms don't require API key
-        return this.http.get(`${this.apiUrl}/f/${slug}/api`, {}, this.retryCount, this.retryDelay);
-    }
-    /**
-     * List all forms
-     */
-    listForms(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        let params = new HttpParams();
-        if (options?.page) {
-            params = params.set('page', options.page.toString());
-        }
-        if (options?.limit) {
-            params = params.set('limit', options.limit.toString());
-        }
-        return this.http.get(`${this.apiUrl}/api/forms`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Create a new form
-     */
-    createForm(config) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!config.title) {
-            return throwError(() => new ValidationError('Form title is required'));
-        }
-        if (!config.fields || config.fields.length === 0) {
-            return throwError(() => new ValidationError('At least one field is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/forms`, config, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Update an existing form
-     */
-    updateForm(formId, config) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!formId) {
-            return throwError(() => new ValidationError('Form ID is required'));
-        }
-        return this.http.put(`${this.apiUrl}/api/forms/${formId}`, config, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Delete a form
-     */
-    deleteForm(formId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!formId) {
-            return throwError(() => new ValidationError('Form ID is required'));
-        }
-        return this.http.delete(`${this.apiUrl}/api/forms/${formId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get form analytics
-     */
-    getAnalytics(formId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!formId) {
-            return throwError(() => new ValidationError('Form ID is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/forms/${formId}/analytics`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Publish a form
-     */
-    publishForm(formId, slug) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!formId) {
-            return throwError(() => new ValidationError('Form ID is required'));
-        }
-        if (!slug) {
-            return throwError(() => new ValidationError('Slug is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/forms/${formId}/publish`, { slug }, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganFormsService, deps: [{ token: MetiganHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganFormsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganFormsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganHttpClient }] });
-
-/**
- * Metigan Contacts Service
- * Service for contact/subscriber management
- */
-class MetiganContactsService {
-    http;
-    apiKey = '';
-    apiUrl = API_URL;
-    timeout = DEFAULT_TIMEOUT;
-    retryCount = DEFAULT_RETRY_COUNT;
-    retryDelay = DEFAULT_RETRY_DELAY;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Initialize the service with API key and options
-     */
-    initialize(apiKey, options) {
-        if (!apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        this.apiKey = apiKey;
-        this.apiUrl = options?.apiUrl || API_URL;
-        this.timeout = options?.timeout || DEFAULT_TIMEOUT;
-        this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
-        this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
-    }
-    /**
-     * Get default headers
-     */
-    getHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            'User-Agent': 'AngularSDK/1.0'
-        };
-    }
-    /**
-     * Validate email format
-     */
-    validateEmail(email) {
-        if (!email || typeof email !== 'string')
-            return false;
-        const parts = email.split('@');
-        if (parts.length !== 2)
-            return false;
-        if (parts[0].length === 0)
-            return false;
-        const domainParts = parts[1].split('.');
-        if (domainParts.length < 2)
-            return false;
-        if (domainParts.some(part => part.length === 0))
-            return false;
-        return true;
-    }
-    /**
-     * Create a new contact
-     */
-    create(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!options.email || !this.validateEmail(options.email)) {
-            return throwError(() => new ValidationError('Valid email is required'));
-        }
-        if (!options.audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/contacts`, options, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get contact by ID
-     */
-    get(contactId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/contacts/${contactId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get contact by email
-     */
-    getByEmail(email, audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!email || !this.validateEmail(email)) {
-            return throwError(() => new ValidationError('Valid email is required'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        let params = new HttpParams();
-        params = params.set('email', email);
-        params = params.set('audienceId', audienceId);
-        return this.http.get(`${this.apiUrl}/api/contacts`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Update a contact
-     */
-    update(contactId, options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        return this.http.put(`${this.apiUrl}/api/contacts/${contactId}`, options, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Delete a contact
-     */
-    delete(contactId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        return this.http.delete(`${this.apiUrl}/api/contacts/${contactId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * List contacts with filters
-     */
-    list(filters) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        let params = new HttpParams();
-        if (filters?.audienceId) {
-            params = params.set('audienceId', filters.audienceId);
-        }
-        if (filters?.status) {
-            params = params.set('status', filters.status);
-        }
-        if (filters?.tag) {
-            params = params.set('tag', filters.tag);
-        }
-        if (filters?.search) {
-            params = params.set('search', filters.search);
-        }
-        if (filters?.page) {
-            params = params.set('page', filters.page.toString());
-        }
-        if (filters?.limit) {
-            params = params.set('limit', filters.limit.toString());
-        }
-        return this.http.get(`${this.apiUrl}/api/contacts`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Search contacts
-     */
-    search(query, audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!query) {
-            return throwError(() => new ValidationError('Search query is required'));
-        }
-        let params = new HttpParams();
-        params = params.set('search', query);
-        if (audienceId) {
-            params = params.set('audienceId', audienceId);
-        }
-        return this.http.get(`${this.apiUrl}/api/contacts/search`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Bulk import contacts
-     */
-    bulkImport(contacts, audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contacts || contacts.length === 0) {
-            return throwError(() => new ValidationError('Contacts array is required'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/contacts/bulk`, { contacts, audienceId }, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Subscribe a contact
-     */
-    subscribe(contactId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/contacts/${contactId}/subscribe`, {}, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Unsubscribe a contact
-     */
-    unsubscribe(contactId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/contacts/${contactId}/unsubscribe`, {}, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Add tags to a contact
-     */
-    addTags(contactId, tags) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        if (!tags || tags.length === 0) {
-            return throwError(() => new ValidationError('Tags array is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/contacts/${contactId}/tags`, { tags }, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Remove tags from a contact
-     */
-    removeTags(contactId, tags) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!contactId) {
-            return throwError(() => new ValidationError('Contact ID is required'));
-        }
-        if (!tags || tags.length === 0) {
-            return throwError(() => new ValidationError('Tags array is required'));
-        }
-        return this.http.delete(`${this.apiUrl}/api/contacts/${contactId}/tags`, {
-            headers: this.getHeaders(),
-            params: { tags: tags.join(',') }
-        }, this.retryCount, this.retryDelay);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganContactsService, deps: [{ token: MetiganHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganContactsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganContactsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganHttpClient }] });
-
-/**
- * Metigan Audiences Service
- * Service for audience/list management
- */
-class MetiganAudiencesService {
-    http;
-    apiKey = '';
-    apiUrl = API_URL;
-    timeout = DEFAULT_TIMEOUT;
-    retryCount = DEFAULT_RETRY_COUNT;
-    retryDelay = DEFAULT_RETRY_DELAY;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Initialize the service with API key and options
-     */
-    initialize(apiKey, options) {
-        if (!apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        this.apiKey = apiKey;
-        this.apiUrl = options?.apiUrl || API_URL;
-        this.timeout = options?.timeout || DEFAULT_TIMEOUT;
-        this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
-        this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
-    }
-    /**
-     * Get default headers
-     */
-    getHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            'User-Agent': 'AngularSDK/1.0'
-        };
-    }
-    /**
-     * Create a new audience
-     */
-    create(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!options.name) {
-            return throwError(() => new ValidationError('Audience name is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/audiences`, options, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get audience by ID
-     */
-    get(audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/audiences/${audienceId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Update an audience
-     */
-    update(audienceId, options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.put(`${this.apiUrl}/api/audiences/${audienceId}`, options, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Delete an audience
-     */
-    delete(audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.delete(`${this.apiUrl}/api/audiences/${audienceId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * List all audiences
-     */
-    list(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        let params = new HttpParams();
-        if (options?.page) {
-            params = params.set('page', options.page.toString());
-        }
-        if (options?.limit) {
-            params = params.set('limit', options.limit.toString());
-        }
-        return this.http.get(`${this.apiUrl}/api/audiences`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get audience statistics
-     */
-    getStats(audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/audiences/${audienceId}/stats`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Clean audience (remove bounced/unsubscribed contacts)
-     */
-    clean(audienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!audienceId) {
-            return throwError(() => new ValidationError('Audience ID is required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/audiences/${audienceId}/clean`, {}, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Merge audiences (source into target)
-     */
-    merge(sourceAudienceId, targetAudienceId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!sourceAudienceId || !targetAudienceId) {
-            return throwError(() => new ValidationError('Source and target audience IDs are required'));
-        }
-        return this.http.post(`${this.apiUrl}/api/audiences/${sourceAudienceId}/merge`, { targetAudienceId }, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganAudiencesService, deps: [{ token: MetiganHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganAudiencesService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganAudiencesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganHttpClient }] });
-
-/**
- * Metigan Templates Service
- * Service for managing email templates
- */
-class MetiganTemplatesService {
-    http;
-    apiKey = '';
-    apiUrl = API_URL;
-    timeout = DEFAULT_TIMEOUT;
-    retryCount = DEFAULT_RETRY_COUNT;
-    retryDelay = DEFAULT_RETRY_DELAY;
-    constructor(http) {
-        this.http = http;
-    }
-    /**
-     * Initialize the service with API key and options
-     */
-    initialize(apiKey, options) {
-        if (!apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        this.apiKey = apiKey;
-        this.apiUrl = options?.apiUrl || API_URL;
-        this.timeout = options?.timeout || DEFAULT_TIMEOUT;
-        this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;
-        this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;
-    }
-    /**
-     * Get default headers
-     */
-    getHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            'User-Agent': 'AngularSDK/1.0'
-        };
-    }
-    /**
-     * List all templates
-     */
-    list(options) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        let params = new HttpParams();
-        if (options?.page) {
-            params = params.set('page', options.page.toString());
-        }
-        if (options?.limit) {
-            params = params.set('limit', options.limit.toString());
-        }
-        return this.http.get(`${this.apiUrl}/api/templates`, {
-            headers: this.getHeaders(),
-            params: params
-        }, this.retryCount, this.retryDelay);
-    }
-    /**
-     * Get template by ID
-     */
-    get(templateId) {
-        if (!this.apiKey) {
-            return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));
-        }
-        if (!templateId) {
-            return throwError(() => new ValidationError('Template ID is required'));
-        }
-        return this.http.get(`${this.apiUrl}/api/templates/${templateId}`, { headers: this.getHeaders() }, this.retryCount, this.retryDelay);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganTemplatesService, deps: [{ token: MetiganHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganTemplatesService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganTemplatesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganHttpClient }] });
-
-/**
- * Main Metigan Service
- * Unified service that provides access to all Metigan modules
- */
-const METIGAN_CONFIG = 'METIGAN_CONFIG';
-class MetiganService {
-    email;
-    forms;
-    contacts;
-    audiences;
-    templates;
-    initialized = false;
-    constructor(emailService, formsService, contactsService, audiencesService, templatesService, config) {
-        this.email = emailService;
-        this.forms = formsService;
-        this.contacts = contactsService;
-        this.audiences = audiencesService;
-        this.templates = templatesService;
-        // Auto-initialize if config is provided via injection
-        if (config) {
-            this.initialize(config);
-        }
-    }
-    /**
-     * Initialize all services with API key and options
-     */
-    initialize(options) {
-        if (!options.apiKey) {
-            throw new MetiganError('API key is required');
-        }
-        const serviceOptions = {
-            apiUrl: options.apiUrl,
-            timeout: options.timeout,
-            retryCount: options.retryCount,
-            retryDelay: options.retryDelay
-        };
-        this.email.initialize(options.apiKey, serviceOptions);
-        this.forms.initialize(options.apiKey, serviceOptions);
-        this.contacts.initialize(options.apiKey, serviceOptions);
-        this.audiences.initialize(options.apiKey, serviceOptions);
-        this.templates.initialize(options.apiKey, serviceOptions);
-        this.initialized = true;
-    }
-    /**
-     * Check if services are initialized
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganService, deps: [{ token: MetiganEmailService }, { token: MetiganFormsService }, { token: MetiganContactsService }, { token: MetiganAudiencesService }, { token: MetiganTemplatesService }, { token: METIGAN_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: MetiganEmailService }, { type: MetiganFormsService }, { type: MetiganContactsService }, { type: MetiganAudiencesService }, { type: MetiganTemplatesService }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [METIGAN_CONFIG]
-                }] }] });
-
-/**
- * Metigan Angular Module
- * Import this module in your Angular app to use Metigan services
- */
-class MetiganModule {
-    /**
-     * Configure Metigan with API key and options
-     * Call this in your root module's imports
-     *
-     * @example
-     * ```typescript
-     * imports: [
-     *   MetiganModule.forRoot({
-     *     apiKey: 'your-api-key'
-     *   })
-     * ]
-     * ```
-     */
-    static forRoot(config) {
-        return {
-            ngModule: MetiganModule,
-            providers: [
-                {
-                    provide: METIGAN_CONFIG,
-                    useValue: config
-                }
-            ]
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: MetiganModule, imports: [HttpClientModule] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganModule, providers: [
-            MetiganHttpClient,
-            MetiganEmailService,
-            MetiganFormsService,
-            MetiganContactsService,
-            MetiganAudiencesService,
-            MetiganTemplatesService,
-            MetiganService
-        ], imports: [HttpClientModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MetiganModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [HttpClientModule],
-                    providers: [
-                        MetiganHttpClient,
-                        MetiganEmailService,
-                        MetiganFormsService,
-                        MetiganContactsService,
-                        MetiganAudiencesService,
-                        MetiganTemplatesService,
-                        MetiganService
-                    ]
-                }]
-        }] });
-
-/**
- * Type definitions for Metigan Angular SDK
- * @version 1.0.0
- */
-
-/**
- * Public API for @metigan/angular
- * Export all public classes, services, and types
- */
-// Services
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { API_URL, ApiError, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY, DEFAULT_TIMEOUT, MAX_FILE_SIZE, METIGAN_CONFIG, MetiganAudiencesService, MetiganContactsService, MetiganEmailService, MetiganError, MetiganFormsService, MetiganHttpClient, MetiganModule, MetiganService, MetiganTemplatesService, SDK_VERSION, ValidationError };
-//# sourceMappingURL=metigan-angular.mjs.map