@metigan/angular 1.0.0

package/dist/esm2022/src/lib/audiences.service.mjs

@@ -0,0 +1,157 @@
+/**
+ * Metigan Audiences Service
+ * Service for audience/list management
+ */
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY } from './config';
+import { ValidationError, MetiganError } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-client.service";
+export 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: i1.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: i1.MetiganHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audiences.service.js","sourceRoot":"","sources":["../../../../src/lib/audiences.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Metigan Audiences Service\r\n * Service for audience/list management\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { HttpParams } from '@angular/common/http';\r\nimport { MetiganHttpClient } from './http-client.service';\r\nimport { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY } from './config';\r\nimport { ValidationError, MetiganError } from './errors';\r\nimport {\r\n  Audience,\r\n  CreateAudienceOptions,\r\n  UpdateAudienceOptions,\r\n  AudienceListResponse,\r\n  AudienceStats,\r\n  PaginationOptions\r\n} from './types';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MetiganAudiencesService {\r\n  private apiKey: string = '';\r\n  private apiUrl: string = API_URL;\r\n  private timeout: number = DEFAULT_TIMEOUT;\r\n  private retryCount: number = DEFAULT_RETRY_COUNT;\r\n  private retryDelay: number = DEFAULT_RETRY_DELAY;\r\n\r\n  constructor(private http: MetiganHttpClient) {}\r\n\r\n  /**\r\n   * Initialize the service with API key and options\r\n   */\r\n  initialize(apiKey: string, options?: { apiUrl?: string; timeout?: number; retryCount?: number; retryDelay?: number }): void {\r\n    if (!apiKey) {\r\n      throw new MetiganError('API key is required');\r\n    }\r\n\r\n    this.apiKey = apiKey;\r\n    this.apiUrl = options?.apiUrl || API_URL;\r\n    this.timeout = options?.timeout || DEFAULT_TIMEOUT;\r\n    this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;\r\n    this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;\r\n  }\r\n\r\n  /**\r\n   * Get default headers\r\n   */\r\n  private getHeaders() {\r\n    return {\r\n      'Content-Type': 'application/json',\r\n      'x-api-key': this.apiKey,\r\n      'User-Agent': 'AngularSDK/1.0'\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create a new audience\r\n   */\r\n  create(options: CreateAudienceOptions): Observable<Audience> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!options.name) {\r\n      return throwError(() => new ValidationError('Audience name is required'));\r\n    }\r\n\r\n    return this.http.post<Audience>(\r\n      `${this.apiUrl}/api/audiences`,\r\n      options,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get audience by ID\r\n   */\r\n  get(audienceId: string): Observable<Audience> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.get<Audience>(\r\n      `${this.apiUrl}/api/audiences/${audienceId}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Update an audience\r\n   */\r\n  update(audienceId: string, options: UpdateAudienceOptions): Observable<Audience> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.put<Audience>(\r\n      `${this.apiUrl}/api/audiences/${audienceId}`,\r\n      options,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Delete an audience\r\n   */\r\n  delete(audienceId: string): Observable<void> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.delete<void>(\r\n      `${this.apiUrl}/api/audiences/${audienceId}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * List all audiences\r\n   */\r\n  list(options?: PaginationOptions): Observable<AudienceListResponse> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    let params = new HttpParams();\r\n    if (options?.page) {\r\n      params = params.set('page', options.page.toString());\r\n    }\r\n    if (options?.limit) {\r\n      params = params.set('limit', options.limit.toString());\r\n    }\r\n\r\n    return this.http.get<AudienceListResponse>(\r\n      `${this.apiUrl}/api/audiences`,\r\n      {\r\n        headers: this.getHeaders(),\r\n        params: params\r\n      },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get audience statistics\r\n   */\r\n  getStats(audienceId: string): Observable<AudienceStats> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.get<AudienceStats>(\r\n      `${this.apiUrl}/api/audiences/${audienceId}/stats`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Clean audience (remove bounced/unsubscribed contacts)\r\n   */\r\n  clean(audienceId: string): Observable<{ removed: number }> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.post<{ removed: number }>(\r\n      `${this.apiUrl}/api/audiences/${audienceId}/clean`,\r\n      {},\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Merge audiences (source into target)\r\n   */\r\n  merge(sourceAudienceId: string, targetAudienceId: string): Observable<Audience> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!sourceAudienceId || !targetAudienceId) {\r\n      return throwError(() => new ValidationError('Source and target audience IDs are required'));\r\n    }\r\n\r\n    return this.http.post<Audience>(\r\n      `${this.apiUrl}/api/audiences/${sourceAudienceId}/merge`,\r\n      { targetAudienceId },\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n}\r\n\r\n"]}

package/dist/esm2022/src/lib/config.mjs

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+export const API_URL = (typeof process !== 'undefined' && process.env?.['METIGAN_API_URL'])
+    || 'https://api.metigan.com';
+/**
+ * SDK Version
+ */
+export const SDK_VERSION = '1.0.0';
+/**
+ * Default timeout for API requests (in milliseconds)
+ */
+export const DEFAULT_TIMEOUT = 30000;
+/**
+ * Default retry configuration
+ */
+export const DEFAULT_RETRY_COUNT = 3;
+export const DEFAULT_RETRY_DELAY = 1000;
+/**
+ * Maximum file size for attachments (7MB)
+ */
+export const MAX_FILE_SIZE = 7 * 1024 * 1024;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxPQUFPLE9BQU8sS0FBSyxXQUFXLElBQUksT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDLGlCQUFpQixDQUFDLENBQUM7T0FDdEYseUJBQXlCLENBQUM7QUFFL0I7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDO0FBRW5DOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEtBQUssQ0FBQztBQUVyQzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLENBQUMsQ0FBQztBQUNyQyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLENBQUM7QUFFeEM7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsQ0FBQyxHQUFHLElBQUksR0FBRyxJQUFJLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogTWV0aWdhbiBMaWJyYXJ5IENvbmZpZ3VyYXRpb25cclxuICogQ2VudHJhbCBjb25maWd1cmF0aW9uIGZpbGUgZm9yIGFsbCBtb2R1bGVzXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIERlZmF1bHQgQVBJIFVSTCBmb3IgTWV0aWdhbiBzZXJ2aWNlc1xyXG4gKiBBbGwgQVBJIGNhbGxzIGFyZSByb3V0ZWQgdGhyb3VnaCB0aGlzIHNpbmdsZSBlbmRwb2ludFxyXG4gKiBcclxuICogQ2FuIGJlIG92ZXJyaWRkZW4gd2l0aCBNRVRJR0FOX0FQSV9VUkwgZW52aXJvbm1lbnQgdmFyaWFibGUgZm9yIHRlc3RpbmdcclxuICovXHJcbmV4cG9ydCBjb25zdCBBUElfVVJMID0gKHR5cGVvZiBwcm9jZXNzICE9PSAndW5kZWZpbmVkJyAmJiBwcm9jZXNzLmVudj8uWydNRVRJR0FOX0FQSV9VUkwnXSkgXHJcbiAgfHwgJ2h0dHBzOi8vYXBpLm1ldGlnYW4uY29tJztcclxuXHJcbi8qKlxyXG4gKiBTREsgVmVyc2lvblxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IFNES19WRVJTSU9OID0gJzEuMC4wJztcclxuXHJcbi8qKlxyXG4gKiBEZWZhdWx0IHRpbWVvdXQgZm9yIEFQSSByZXF1ZXN0cyAoaW4gbWlsbGlzZWNvbmRzKVxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IERFRkFVTFRfVElNRU9VVCA9IDMwMDAwO1xyXG5cclxuLyoqXHJcbiAqIERlZmF1bHQgcmV0cnkgY29uZmlndXJhdGlvblxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IERFRkFVTFRfUkVUUllfQ09VTlQgPSAzO1xyXG5leHBvcnQgY29uc3QgREVGQVVMVF9SRVRSWV9ERUxBWSA9IDEwMDA7XHJcblxyXG4vKipcclxuICogTWF4aW11bSBmaWxlIHNpemUgZm9yIGF0dGFjaG1lbnRzICg3TUIpXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgTUFYX0ZJTEVfU0laRSA9IDcgKiAxMDI0ICogMTAyNDtcclxuXHJcbiJdfQ==

package/dist/esm2022/src/lib/contacts.service.mjs

@@ -0,0 +1,267 @@
+/**
+ * Metigan Contacts Service
+ * Service for contact/subscriber management
+ */
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY } from './config';
+import { ValidationError, MetiganError } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-client.service";
+export 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: i1.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: i1.MetiganHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contacts.service.js","sourceRoot":"","sources":["../../../../src/lib/contacts.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Metigan Contacts Service\r\n * Service for contact/subscriber management\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { HttpParams } from '@angular/common/http';\r\nimport { MetiganHttpClient } from './http-client.service';\r\nimport { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY } from './config';\r\nimport { ValidationError, MetiganError } from './errors';\r\nimport {\r\n  Contact,\r\n  CreateContactOptions,\r\n  UpdateContactOptions,\r\n  ContactListFilters,\r\n  ContactListResponse,\r\n  BulkContactResult\r\n} from './types';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MetiganContactsService {\r\n  private apiKey: string = '';\r\n  private apiUrl: string = API_URL;\r\n  private timeout: number = DEFAULT_TIMEOUT;\r\n  private retryCount: number = DEFAULT_RETRY_COUNT;\r\n  private retryDelay: number = DEFAULT_RETRY_DELAY;\r\n\r\n  constructor(private http: MetiganHttpClient) {}\r\n\r\n  /**\r\n   * Initialize the service with API key and options\r\n   */\r\n  initialize(apiKey: string, options?: { apiUrl?: string; timeout?: number; retryCount?: number; retryDelay?: number }): void {\r\n    if (!apiKey) {\r\n      throw new MetiganError('API key is required');\r\n    }\r\n\r\n    this.apiKey = apiKey;\r\n    this.apiUrl = options?.apiUrl || API_URL;\r\n    this.timeout = options?.timeout || DEFAULT_TIMEOUT;\r\n    this.retryCount = options?.retryCount || DEFAULT_RETRY_COUNT;\r\n    this.retryDelay = options?.retryDelay || DEFAULT_RETRY_DELAY;\r\n  }\r\n\r\n  /**\r\n   * Get default headers\r\n   */\r\n  private getHeaders() {\r\n    return {\r\n      'Content-Type': 'application/json',\r\n      'x-api-key': this.apiKey,\r\n      'User-Agent': 'AngularSDK/1.0'\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Validate email format\r\n   */\r\n  private validateEmail(email: string): boolean {\r\n    if (!email || typeof email !== 'string') return false;\r\n    const parts = email.split('@');\r\n    if (parts.length !== 2) return false;\r\n    if (parts[0].length === 0) return false;\r\n    const domainParts = parts[1].split('.');\r\n    if (domainParts.length < 2) return false;\r\n    if (domainParts.some(part => part.length === 0)) return false;\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Create a new contact\r\n   */\r\n  create(options: CreateContactOptions): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!options.email || !this.validateEmail(options.email)) {\r\n      return throwError(() => new ValidationError('Valid email is required'));\r\n    }\r\n\r\n    if (!options.audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.post<Contact>(\r\n      `${this.apiUrl}/api/contacts`,\r\n      options,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get contact by ID\r\n   */\r\n  get(contactId: string): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    return this.http.get<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get contact by email\r\n   */\r\n  getByEmail(email: string, audienceId: string): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!email || !this.validateEmail(email)) {\r\n      return throwError(() => new ValidationError('Valid email is required'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    let params = new HttpParams();\r\n    params = params.set('email', email);\r\n    params = params.set('audienceId', audienceId);\r\n\r\n    return this.http.get<Contact>(\r\n      `${this.apiUrl}/api/contacts`,\r\n      {\r\n        headers: this.getHeaders(),\r\n        params: params\r\n      },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Update a contact\r\n   */\r\n  update(contactId: string, options: UpdateContactOptions): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    return this.http.put<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}`,\r\n      options,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Delete a contact\r\n   */\r\n  delete(contactId: string): Observable<void> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    return this.http.delete<void>(\r\n      `${this.apiUrl}/api/contacts/${contactId}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * List contacts with filters\r\n   */\r\n  list(filters?: ContactListFilters): Observable<ContactListResponse> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    let params = new HttpParams();\r\n    if (filters?.audienceId) {\r\n      params = params.set('audienceId', filters.audienceId);\r\n    }\r\n    if (filters?.status) {\r\n      params = params.set('status', filters.status);\r\n    }\r\n    if (filters?.tag) {\r\n      params = params.set('tag', filters.tag);\r\n    }\r\n    if (filters?.search) {\r\n      params = params.set('search', filters.search);\r\n    }\r\n    if (filters?.page) {\r\n      params = params.set('page', filters.page.toString());\r\n    }\r\n    if (filters?.limit) {\r\n      params = params.set('limit', filters.limit.toString());\r\n    }\r\n\r\n    return this.http.get<ContactListResponse>(\r\n      `${this.apiUrl}/api/contacts`,\r\n      {\r\n        headers: this.getHeaders(),\r\n        params: params\r\n      },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Search contacts\r\n   */\r\n  search(query: string, audienceId?: string): Observable<Contact[]> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!query) {\r\n      return throwError(() => new ValidationError('Search query is required'));\r\n    }\r\n\r\n    let params = new HttpParams();\r\n    params = params.set('search', query);\r\n    if (audienceId) {\r\n      params = params.set('audienceId', audienceId);\r\n    }\r\n\r\n    return this.http.get<Contact[]>(\r\n      `${this.apiUrl}/api/contacts/search`,\r\n      {\r\n        headers: this.getHeaders(),\r\n        params: params\r\n      },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Bulk import contacts\r\n   */\r\n  bulkImport(contacts: CreateContactOptions[], audienceId: string): Observable<BulkContactResult> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contacts || contacts.length === 0) {\r\n      return throwError(() => new ValidationError('Contacts array is required'));\r\n    }\r\n\r\n    if (!audienceId) {\r\n      return throwError(() => new ValidationError('Audience ID is required'));\r\n    }\r\n\r\n    return this.http.post<BulkContactResult>(\r\n      `${this.apiUrl}/api/contacts/bulk`,\r\n      { contacts, audienceId },\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Subscribe a contact\r\n   */\r\n  subscribe(contactId: string): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    return this.http.post<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}/subscribe`,\r\n      {},\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe a contact\r\n   */\r\n  unsubscribe(contactId: string): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    return this.http.post<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}/unsubscribe`,\r\n      {},\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Add tags to a contact\r\n   */\r\n  addTags(contactId: string, tags: string[]): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    if (!tags || tags.length === 0) {\r\n      return throwError(() => new ValidationError('Tags array is required'));\r\n    }\r\n\r\n    return this.http.post<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}/tags`,\r\n      { tags },\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Remove tags from a contact\r\n   */\r\n  removeTags(contactId: string, tags: string[]): Observable<Contact> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!contactId) {\r\n      return throwError(() => new ValidationError('Contact ID is required'));\r\n    }\r\n\r\n    if (!tags || tags.length === 0) {\r\n      return throwError(() => new ValidationError('Tags array is required'));\r\n    }\r\n\r\n    return this.http.delete<Contact>(\r\n      `${this.apiUrl}/api/contacts/${contactId}/tags`,\r\n      {\r\n        headers: this.getHeaders(),\r\n        params: { tags: tags.join(',') }\r\n      },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n}\r\n\r\n"]}