@metigan/angular 1.0.0

package/dist/fesm2022/metigan-angular.mjs

@@ -0,0 +1,1241 @@
+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