@metigan/angular 1.0.0

package/dist/esm2022/src/lib/http-client.service.mjs

@@ -0,0 +1,111 @@
+/**
+ * HTTP Client Service for Metigan SDK
+ * Wraps Angular HttpClient with retry logic and error handling
+ */
+import { Injectable } from '@angular/core';
+import { throwError, timer } from 'rxjs';
+import { catchError, retryWhen, mergeMap, map } from 'rxjs/operators';
+import { ApiError, MetiganError } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export 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 }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.service.js","sourceRoot":"","sources":["../../../../src/lib/http-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * HTTP Client Service for Metigan SDK\r\n * Wraps Angular HttpClient with retry logic and error handling\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams, HttpErrorResponse } from '@angular/common/http';\r\nimport { Observable, throwError, timer } from 'rxjs';\r\nimport { catchError, retryWhen, mergeMap, map } from 'rxjs/operators';\r\nimport { ApiError, MetiganError } from './errors';\r\n\r\nexport interface HttpOptions {\r\n  headers?: HttpHeaders | { [header: string]: string | string[] };\r\n  params?: HttpParams | { [param: string]: any };\r\n  timeout?: number;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MetiganHttpClient {\r\n  constructor(private http: HttpClient) {}\r\n\r\n  /**\r\n   * Make GET request with retry logic\r\n   */\r\n  get<T>(url: string, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {\r\n    const opts = this.buildOptions(options);\r\n    \r\n    return (this.http.get<T>(url, opts) as Observable<T>).pipe(\r\n      map((response: T) => response),\r\n      retryWhen(errors =>\r\n        errors.pipe(\r\n          mergeMap((error: HttpErrorResponse, index: number) => {\r\n            if (index < retryCount && this.shouldRetry(error)) {\r\n              return timer(retryDelay * (index + 1));\r\n            }\r\n            return throwError(() => error);\r\n          })\r\n        )\r\n      ),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Make POST request with retry logic\r\n   */\r\n  post<T>(url: string, body: any, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {\r\n    const opts = this.buildOptions(options);\r\n    \r\n    return (this.http.post<T>(url, body, opts) as Observable<T>).pipe(\r\n      map((response: T) => response),\r\n      retryWhen(errors =>\r\n        errors.pipe(\r\n          mergeMap((error: HttpErrorResponse, index: number) => {\r\n            if (index < retryCount && this.shouldRetry(error)) {\r\n              return timer(retryDelay * (index + 1));\r\n            }\r\n            return throwError(() => error);\r\n          })\r\n        )\r\n      ),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Make PUT request with retry logic\r\n   */\r\n  put<T>(url: string, body: any, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {\r\n    const opts = this.buildOptions(options);\r\n    \r\n    return (this.http.put<T>(url, body, opts) as Observable<T>).pipe(\r\n      map((response: T) => response),\r\n      retryWhen(errors =>\r\n        errors.pipe(\r\n          mergeMap((error: HttpErrorResponse, index: number) => {\r\n            if (index < retryCount && this.shouldRetry(error)) {\r\n              return timer(retryDelay * (index + 1));\r\n            }\r\n            return throwError(() => error);\r\n          })\r\n        )\r\n      ),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Make DELETE request with retry logic\r\n   */\r\n  delete<T>(url: string, options?: HttpOptions, retryCount: number = 3, retryDelay: number = 1000): Observable<T> {\r\n    const opts = this.buildOptions(options);\r\n    \r\n    return (this.http.delete<T>(url, opts) as Observable<T>).pipe(\r\n      map((response: T) => response),\r\n      retryWhen(errors =>\r\n        errors.pipe(\r\n          mergeMap((error: HttpErrorResponse, index: number) => {\r\n            if (index < retryCount && this.shouldRetry(error)) {\r\n              return timer(retryDelay * (index + 1));\r\n            }\r\n            return throwError(() => error);\r\n          })\r\n        )\r\n      ),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Build HTTP options with timeout\r\n   */\r\n  private buildOptions(options?: HttpOptions): any {\r\n    const opts: any = {\r\n      observe: 'body' as const\r\n    };\r\n    \r\n    if (options?.headers) {\r\n      opts.headers = options.headers;\r\n    }\r\n    \r\n    if (options?.params) {\r\n      opts.params = options.params;\r\n    }\r\n\r\n    // Angular HttpClient doesn't support timeout directly\r\n    // Timeout should be handled at the interceptor level if needed\r\n    \r\n    return opts;\r\n  }\r\n\r\n  /**\r\n   * Determine if error should trigger retry\r\n   */\r\n  private shouldRetry(error: HttpErrorResponse): boolean {\r\n    // Retry on server errors (5xx) or network errors\r\n    return error.status >= 500 || error.status === 0 || !error.status;\r\n  }\r\n\r\n  /**\r\n   * Handle HTTP errors\r\n   */\r\n  private handleError = (error: HttpErrorResponse): Observable<never> => {\r\n    if (error.error instanceof ErrorEvent) {\r\n      // Client-side error\r\n      return throwError(() => new MetiganError(`Network error: ${error.error.message}`));\r\n    } else {\r\n      // Server-side error\r\n      const message = error.error?.message || error.error?.error || `Request failed with status ${error.status}`;\r\n      return throwError(() => new ApiError(message, error.status));\r\n    }\r\n  };\r\n}\r\n\r\n"]}

package/dist/esm2022/src/lib/metigan.module.mjs

@@ -0,0 +1,67 @@
+/**
+ * Metigan Angular Module
+ * Import this module in your Angular app to use Metigan services
+ */
+import { NgModule } from '@angular/core';
+import { HttpClientModule } from '@angular/common/http';
+import { MetiganService, METIGAN_CONFIG } from './metigan.service';
+import { MetiganHttpClient } from './http-client.service';
+import { MetiganEmailService } from './email.service';
+import { MetiganFormsService } from './forms.service';
+import { MetiganContactsService } from './contacts.service';
+import { MetiganAudiencesService } from './audiences.service';
+import { MetiganTemplatesService } from './templates.service';
+import * as i0 from "@angular/core";
+export 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
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,72 @@
+/**
+ * Main Metigan Service
+ * Unified service that provides access to all Metigan modules
+ */
+import { Injectable, Inject, Optional } from '@angular/core';
+import { MetiganError } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "./email.service";
+import * as i2 from "./forms.service";
+import * as i3 from "./contacts.service";
+import * as i4 from "./audiences.service";
+import * as i5 from "./templates.service";
+export const METIGAN_CONFIG = 'METIGAN_CONFIG';
+export 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: i1.MetiganEmailService }, { token: i2.MetiganFormsService }, { token: i3.MetiganContactsService }, { token: i4.MetiganAudiencesService }, { token: i5.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: i1.MetiganEmailService }, { type: i2.MetiganFormsService }, { type: i3.MetiganContactsService }, { type: i4.MetiganAudiencesService }, { type: i5.MetiganTemplatesService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [METIGAN_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,85 @@
+/**
+ * Metigan Templates Service
+ * Service for managing email templates
+ */
+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 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: i1.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: i1.MetiganHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for Metigan Angular SDK
+ * @version 1.0.0
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\r\n * Type definitions for Metigan Angular SDK\r\n * @version 1.0.0\r\n */\r\n\r\n// ============================================\r\n// EMAIL TYPES\r\n// ============================================\r\n\r\n/**\r\n * Email attachment interface for Angular\r\n */\r\nexport interface EmailAttachment {\r\n  content: ArrayBuffer | Uint8Array | string;\r\n  filename: string;\r\n  contentType: string;\r\n}\r\n\r\n/**\r\n * Email options interface\r\n */\r\nexport interface EmailOptions {\r\n  /** Sender email address (or Name <email>) */\r\n  from: string;\r\n  /** List of recipient email addresses */\r\n  recipients: string[];\r\n  /** Email subject */\r\n  subject: string;\r\n  /** Email content (HTML supported) - Required if not using templateId */\r\n  content?: string;\r\n  /** Template ID for using pre-created templates (optional) */\r\n  templateId?: string;\r\n  /** Optional file attachments */\r\n  attachments?: File[] | EmailAttachment[];\r\n  /** Optional CC recipients */\r\n  cc?: string[];\r\n  /** Optional BCC recipients */\r\n  bcc?: string[];\r\n  /** Optional reply-to address */\r\n  replyTo?: string;\r\n}\r\n\r\n/**\r\n * API response interface for successful email\r\n */\r\nexport interface EmailSuccessResponse {\r\n  success: true;\r\n  message: string;\r\n  successfulEmails: {\r\n    recipient: string;\r\n    trackingId: string;\r\n  }[];\r\n  failedEmails: {\r\n    recipient: string;\r\n    error: string;\r\n  }[];\r\n  recipientCount: number;\r\n  emailsRemaining: number;\r\n}\r\n\r\n/**\r\n * API error response interfaces\r\n */\r\nexport interface EmailErrorResponse {\r\n  error: string;\r\n  message: string;\r\n}\r\n\r\n/**\r\n * Union type for all possible API responses\r\n */\r\nexport type EmailApiResponse = EmailSuccessResponse | EmailErrorResponse;\r\n\r\n// ============================================\r\n// FORM TYPES\r\n// ============================================\r\n\r\n/**\r\n * Form field types\r\n */\r\nexport type FormFieldType = \r\n  | 'text'\r\n  | 'email'\r\n  | 'number'\r\n  | 'textarea'\r\n  | 'select'\r\n  | 'checkbox'\r\n  | 'radio'\r\n  | 'date'\r\n  | 'phone'\r\n  | 'url'\r\n  | 'file'\r\n  | 'step'\r\n  | 'password'\r\n  | 'rating'\r\n  | 'slider'\r\n  | 'heading'\r\n  | 'image-choice'\r\n  | 'matrix';\r\n\r\n/**\r\n * Form field configuration\r\n */\r\nexport interface FormFieldConfig {\r\n  id: string;\r\n  type: FormFieldType;\r\n  label: string;\r\n  placeholder?: string;\r\n  required?: boolean;\r\n  helpText?: string;\r\n  options?: string[];\r\n  imageUrls?: string[];\r\n  defaultValue?: string | number | boolean;\r\n}\r\n\r\n/**\r\n * Form settings\r\n */\r\nexport interface FormSettings {\r\n  successMessage?: string;\r\n  processingMessage?: string;\r\n  redirectUrl?: string;\r\n  notifyEmail?: string;\r\n  enableCaptcha?: boolean;\r\n  storeResponses?: boolean;\r\n  allowMultipleSubmissions?: boolean;\r\n  showProgressBar?: boolean;\r\n}\r\n\r\n/**\r\n * Complete form configuration\r\n */\r\nexport interface FormConfig {\r\n  id?: string;\r\n  title: string;\r\n  description?: string;\r\n  coverImage?: string;\r\n  fields: FormFieldConfig[];\r\n  audienceId?: string;\r\n  settings?: FormSettings;\r\n  published?: boolean;\r\n  publishedUrl?: string;\r\n  slug?: string;\r\n  analytics?: {\r\n    views: number;\r\n    submissions: number;\r\n    conversionRate?: number;\r\n  };\r\n  createdAt?: Date;\r\n  updatedAt?: Date;\r\n}\r\n\r\n/**\r\n * Form submission data\r\n */\r\nexport interface FormSubmissionData {\r\n  [fieldId: string]: any;\r\n}\r\n\r\n/**\r\n * Form submission options\r\n */\r\nexport interface FormSubmissionOptions {\r\n  formId: string;\r\n  data: FormSubmissionData;\r\n}\r\n\r\n/**\r\n * Form submission response\r\n */\r\nexport interface FormSubmissionResponse {\r\n  success: boolean;\r\n  message: string;\r\n  submissionId?: string;\r\n}\r\n\r\n/**\r\n * Form list response\r\n */\r\nexport interface FormListResponse {\r\n  forms: FormConfig[];\r\n  pagination: {\r\n    total: number;\r\n    page: number;\r\n    limit: number;\r\n    pages: number;\r\n  };\r\n}\r\n\r\n// ============================================\r\n// CONTACT TYPES\r\n// ============================================\r\n\r\n/**\r\n * Contact status\r\n */\r\nexport type ContactStatus = 'subscribed' | 'unsubscribed' | 'pending' | 'bounced' | 'complained';\r\n\r\n/**\r\n * Contact data\r\n */\r\nexport interface Contact {\r\n  id?: string;\r\n  email: string;\r\n  firstName?: string;\r\n  lastName?: string;\r\n  phone?: string;\r\n  status: ContactStatus;\r\n  audienceId: string;\r\n  tags?: string[];\r\n  customFields?: Record<string, any>;\r\n  createdAt?: Date;\r\n  updatedAt?: Date;\r\n}\r\n\r\n/**\r\n * Contact creation options\r\n */\r\nexport interface CreateContactOptions {\r\n  email: string;\r\n  firstName?: string;\r\n  lastName?: string;\r\n  phone?: string;\r\n  audienceId: string;\r\n  tags?: string[];\r\n  customFields?: Record<string, any>;\r\n  status?: ContactStatus;\r\n}\r\n\r\n/**\r\n * Contact update options\r\n */\r\nexport interface UpdateContactOptions {\r\n  firstName?: string;\r\n  lastName?: string;\r\n  phone?: string;\r\n  tags?: string[];\r\n  customFields?: Record<string, any>;\r\n  status?: ContactStatus;\r\n}\r\n\r\n/**\r\n * Contact list filters\r\n */\r\nexport interface ContactListFilters {\r\n  audienceId?: string;\r\n  status?: ContactStatus;\r\n  tag?: string;\r\n  search?: string;\r\n  page?: number;\r\n  limit?: number;\r\n}\r\n\r\n/**\r\n * Contact list response\r\n */\r\nexport interface ContactListResponse {\r\n  contacts: Contact[];\r\n  pagination: {\r\n    total: number;\r\n    page: number;\r\n    limit: number;\r\n    pages: number;\r\n  };\r\n}\r\n\r\n/**\r\n * Bulk contact operation result\r\n */\r\nexport interface BulkContactResult {\r\n  success: boolean;\r\n  imported: number;\r\n  failed: number;\r\n  errors?: { email: string; error: string }[];\r\n}\r\n\r\n// ============================================\r\n// AUDIENCE TYPES\r\n// ============================================\r\n\r\n/**\r\n * Audience data\r\n */\r\nexport interface Audience {\r\n  id?: string;\r\n  name: string;\r\n  description?: string;\r\n  count: number;\r\n  createdAt?: Date;\r\n  updatedAt?: Date;\r\n}\r\n\r\n/**\r\n * Audience creation options\r\n */\r\nexport interface CreateAudienceOptions {\r\n  name: string;\r\n  description?: string;\r\n}\r\n\r\n/**\r\n * Audience update options\r\n */\r\nexport interface UpdateAudienceOptions {\r\n  name?: string;\r\n  description?: string;\r\n}\r\n\r\n/**\r\n * Audience list response\r\n */\r\nexport interface AudienceListResponse {\r\n  audiences: Audience[];\r\n  pagination: {\r\n    total: number;\r\n    page: number;\r\n    limit: number;\r\n    pages: number;\r\n  };\r\n}\r\n\r\n/**\r\n * Audience statistics\r\n */\r\nexport interface AudienceStats {\r\n  total: number;\r\n  subscribed: number;\r\n  unsubscribed: number;\r\n  pending: number;\r\n  bounced: number;\r\n  complained: number;\r\n  growthRate?: number;\r\n}\r\n\r\n// ============================================\r\n// TEMPLATE TYPES\r\n// ============================================\r\n\r\n/**\r\n * Email template data\r\n */\r\nexport interface EmailTemplate {\r\n  id: string;\r\n  name: string;\r\n  subject: string;\r\n  components?: any[];\r\n  styles?: any;\r\n  createdAt?: Date;\r\n  updatedAt?: Date;\r\n}\r\n\r\n/**\r\n * Email template list response\r\n */\r\nexport interface EmailTemplateListResponse {\r\n  templates: EmailTemplate[];\r\n  pagination: {\r\n    total: number;\r\n    page: number;\r\n    limit: number;\r\n    pages: number;\r\n  };\r\n}\r\n\r\n// ============================================\r\n// COMMON TYPES\r\n// ============================================\r\n\r\n/**\r\n * Pagination options\r\n */\r\nexport interface PaginationOptions {\r\n  page?: number;\r\n  limit?: number;\r\n}\r\n\r\n/**\r\n * Client options for Metigan\r\n */\r\nexport interface MetiganClientOptions {\r\n  /** API Key */\r\n  apiKey: string;\r\n  /** User ID for logging */\r\n  userId?: string;\r\n  /** Disable logging */\r\n  disableLogs?: boolean;\r\n  /** Request timeout in ms */\r\n  timeout?: number;\r\n  /** Number of retries */\r\n  retryCount?: number;\r\n  /** Delay between retries in ms */\r\n  retryDelay?: number;\r\n  /** Enable debug mode */\r\n  debug?: boolean;\r\n  /** Custom API URL */\r\n  apiUrl?: string;\r\n}\r\n\r\n"]}