@metigan/angular 1.0.0

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

@@ -0,0 +1,267 @@
+/**
+ * Metigan Email Service
+ * Service for sending emails through the Metigan API
+ */
+import { Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY, MAX_FILE_SIZE } from './config';
+import { ValidationError, MetiganError } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-client.service";
+export 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: i1.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: i1.MetiganHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"email.service.js","sourceRoot":"","sources":["../../../../src/lib/email.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Metigan Email Service\r\n * Service for sending emails through the Metigan API\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { MetiganHttpClient } from './http-client.service';\r\nimport { API_URL, DEFAULT_TIMEOUT, DEFAULT_RETRY_COUNT, DEFAULT_RETRY_DELAY, MAX_FILE_SIZE } from './config';\r\nimport { ValidationError, MetiganError } from './errors';\r\nimport { EmailOptions, EmailApiResponse, EmailSuccessResponse, EmailAttachment } from './types';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MetiganEmailService {\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   * Validate email address 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   * Extract email address from \"Name <email>\" format\r\n   */\r\n  private extractEmailAddress(from: string): string {\r\n    if (!from) return '';\r\n    const angleMatch = from.match(/<([^>]+)>/);\r\n    if (angleMatch) {\r\n      return angleMatch[1].trim();\r\n    }\r\n    return from.trim();\r\n  }\r\n\r\n  /**\r\n   * Validate email options\r\n   */\r\n  private validateOptions(options: EmailOptions): void {\r\n    if (!options.from) {\r\n      throw new ValidationError('Sender email (from) is required');\r\n    }\r\n\r\n    if (!options.recipients || !Array.isArray(options.recipients) || options.recipients.length === 0) {\r\n      throw new ValidationError('Recipients must be a non-empty array');\r\n    }\r\n\r\n    if (!options.subject) {\r\n      throw new ValidationError('Subject is required');\r\n    }\r\n\r\n    if (!options.content && !options.templateId) {\r\n      throw new ValidationError('Either content or templateId is required');\r\n    }\r\n\r\n    const fromEmail = this.extractEmailAddress(options.from);\r\n    if (!this.validateEmail(fromEmail)) {\r\n      throw new ValidationError(`Invalid sender email format: ${fromEmail}`);\r\n    }\r\n\r\n    for (const recipient of options.recipients) {\r\n      const recipientEmail = this.extractEmailAddress(recipient);\r\n      if (!this.validateEmail(recipientEmail)) {\r\n        throw new ValidationError(`Invalid recipient email format: ${recipientEmail}`);\r\n      }\r\n    }\r\n\r\n    if (options.cc) {\r\n      for (const cc of options.cc) {\r\n        const ccEmail = this.extractEmailAddress(cc);\r\n        if (!this.validateEmail(ccEmail)) {\r\n          throw new ValidationError(`Invalid CC email format: ${ccEmail}`);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (options.bcc) {\r\n      for (const bcc of options.bcc) {\r\n        const bccEmail = this.extractEmailAddress(bcc);\r\n        if (!this.validateEmail(bccEmail)) {\r\n          throw new ValidationError(`Invalid BCC email format: ${bccEmail}`);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (options.replyTo) {\r\n      const replyToEmail = this.extractEmailAddress(options.replyTo);\r\n      if (!this.validateEmail(replyToEmail)) {\r\n        throw new ValidationError(`Invalid reply-to email format: ${replyToEmail}`);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Process attachments for FormData\r\n   */\r\n  private async processAttachments(attachments: File[] | EmailAttachment[]): Promise<FormData> {\r\n    const formData = new FormData();\r\n\r\n    for (const file of attachments) {\r\n      if (file instanceof File) {\r\n        if (file.size > MAX_FILE_SIZE) {\r\n          throw new MetiganError(`File ${file.name} exceeds the maximum size of 7MB`);\r\n        }\r\n        formData.append('files', file);\r\n      } else {\r\n        const attachment = file as EmailAttachment;\r\n        \r\n        // Convert content to Blob\r\n        let blob: Blob;\r\n        if (attachment.content instanceof ArrayBuffer) {\r\n          blob = new Blob([attachment.content], { type: attachment.contentType });\r\n        } else if (attachment.content instanceof Uint8Array) {\r\n          blob = new Blob([attachment.content], { type: attachment.contentType });\r\n        } else if (typeof attachment.content === 'string') {\r\n          // Base64 string\r\n          const byteCharacters = atob(attachment.content);\r\n          const byteNumbers = new Array(byteCharacters.length);\r\n          for (let i = 0; i < byteCharacters.length; i++) {\r\n            byteNumbers[i] = byteCharacters.charCodeAt(i);\r\n          }\r\n          const byteArray = new Uint8Array(byteNumbers);\r\n          blob = new Blob([byteArray], { type: attachment.contentType });\r\n        } else {\r\n          throw new MetiganError('Invalid attachment content type');\r\n        }\r\n\r\n        if (blob.size > MAX_FILE_SIZE) {\r\n          throw new MetiganError(`File ${attachment.filename} exceeds the maximum size of 7MB`);\r\n        }\r\n\r\n        const fileObj = new File([blob], attachment.filename, { type: attachment.contentType });\r\n        formData.append('files', fileObj);\r\n      }\r\n    }\r\n\r\n    return formData;\r\n  }\r\n\r\n  /**\r\n   * Send an email\r\n   */\r\n  sendEmail(options: EmailOptions): Observable<EmailSuccessResponse> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    try {\r\n      this.validateOptions(options);\r\n    } catch (error) {\r\n      return throwError(() => error);\r\n    }\r\n\r\n    const headers = {\r\n      'x-api-key': this.apiKey,\r\n      'User-Agent': 'AngularSDK/1.0'\r\n    };\r\n\r\n    // If attachments, use FormData\r\n    if (options.attachments && options.attachments.length > 0) {\r\n      return new Observable(observer => {\r\n        this.processAttachments(options.attachments!).then(formData => {\r\n          formData.append('from', options.from);\r\n          formData.append('recipients', JSON.stringify(options.recipients));\r\n          formData.append('subject', options.subject);\r\n          \r\n          if (options.templateId) {\r\n            formData.append('useTemplate', 'true');\r\n            formData.append('templateId', options.templateId);\r\n          } else if (options.content) {\r\n            formData.append('content', options.content);\r\n          }\r\n\r\n          if (options.cc && options.cc.length > 0) {\r\n            formData.append('cc', JSON.stringify(options.cc));\r\n          }\r\n\r\n          if (options.bcc && options.bcc.length > 0) {\r\n            formData.append('bcc', JSON.stringify(options.bcc));\r\n          }\r\n\r\n          if (options.replyTo) {\r\n            formData.append('replyTo', options.replyTo);\r\n          }\r\n\r\n          const httpOptions = {\r\n            headers: headers\r\n          };\r\n\r\n          this.http.post<EmailApiResponse>(`${this.apiUrl}/api/email/send`, formData, httpOptions, this.retryCount, this.retryDelay)\r\n            .pipe(\r\n              map(response => {\r\n                if ('success' in response && response.success) {\r\n                  return response as EmailSuccessResponse;\r\n                } else {\r\n                  throw new MetiganError((response as any).message || 'Failed to send email');\r\n                }\r\n              })\r\n            )\r\n            .subscribe({\r\n              next: (response) => observer.next(response),\r\n              error: (error) => observer.error(error),\r\n              complete: () => observer.complete()\r\n            });\r\n        }).catch(error => observer.error(error));\r\n      });\r\n    } else {\r\n      // No attachments, use JSON\r\n      const body = {\r\n        from: options.from,\r\n        recipients: options.recipients,\r\n        subject: options.subject\r\n      };\r\n\r\n      if (options.templateId) {\r\n        (body as any).useTemplate = 'true';\r\n        (body as any).templateId = options.templateId;\r\n      } else if (options.content) {\r\n        (body as any).content = options.content;\r\n      }\r\n\r\n      if (options.cc && options.cc.length > 0) {\r\n        (body as any).cc = options.cc;\r\n      }\r\n\r\n      if (options.bcc && options.bcc.length > 0) {\r\n        (body as any).bcc = options.bcc;\r\n      }\r\n\r\n      if (options.replyTo) {\r\n        (body as any).replyTo = options.replyTo;\r\n      }\r\n\r\n      const httpOptions = {\r\n        headers: {\r\n          ...headers,\r\n          'Content-Type': 'application/json'\r\n        }\r\n      };\r\n\r\n      return this.http.post<EmailApiResponse>(`${this.apiUrl}/api/email/send`, body, httpOptions, this.retryCount, this.retryDelay)\r\n        .pipe(\r\n          map(response => {\r\n            if ('success' in response && response.success) {\r\n              return response as EmailSuccessResponse;\r\n            } else {\r\n              throw new MetiganError((response as any).message || 'Failed to send email');\r\n            }\r\n          })\r\n        );\r\n    }\r\n  }\r\n}\r\n\r\n\r\n"]}

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

@@ -0,0 +1,40 @@
+/**
+ * Custom error classes for Metigan SDK
+ */
+/**
+ * Base error class for all Metigan errors
+ */
+export class MetiganError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MetiganError';
+        Object.setPrototypeOf(this, MetiganError.prototype);
+    }
+}
+/**
+ * Validation error - thrown when input validation fails
+ */
+export 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
+ */
+export 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,180 @@
+/**
+ * Metigan Forms Service
+ * Service for form management and submissions
+ */
+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 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: i1.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: i1.MetiganHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms.service.js","sourceRoot":"","sources":["../../../../src/lib/forms.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Metigan Forms Service\r\n * Service for form management and submissions\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  FormConfig,\r\n  FormSubmissionOptions,\r\n  FormSubmissionResponse,\r\n  FormListResponse,\r\n  PaginationOptions\r\n} from './types';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MetiganFormsService {\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   * Submit form data\r\n   */\r\n  submit(options: FormSubmissionOptions): Observable<FormSubmissionResponse> {\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.formId) {\r\n      return throwError(() => new ValidationError('Form ID is required'));\r\n    }\r\n\r\n    if (!options.data || Object.keys(options.data).length === 0) {\r\n      return throwError(() => new ValidationError('Submission data is required'));\r\n    }\r\n\r\n    const body = {\r\n      formId: options.formId,\r\n      data: options.data\r\n    };\r\n\r\n    return this.http.post<FormSubmissionResponse>(\r\n      `${this.apiUrl}/api/submissions`,\r\n      body,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get form by ID or slug\r\n   */\r\n  getForm(formIdOrSlug: string): Observable<FormConfig> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!formIdOrSlug) {\r\n      return throwError(() => new ValidationError('Form ID or slug is required'));\r\n    }\r\n\r\n    return this.http.get<FormConfig>(\r\n      `${this.apiUrl}/api/forms/${formIdOrSlug}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get public form by slug\r\n   */\r\n  getPublicForm(slug: string): Observable<FormConfig> {\r\n    if (!slug) {\r\n      return throwError(() => new ValidationError('Form slug is required'));\r\n    }\r\n\r\n    // Public forms don't require API key\r\n    return this.http.get<FormConfig>(\r\n      `${this.apiUrl}/f/${slug}/api`,\r\n      {},\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * List all forms\r\n   */\r\n  listForms(options?: PaginationOptions): Observable<FormListResponse> {\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<FormListResponse>(\r\n      `${this.apiUrl}/api/forms`,\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   * Create a new form\r\n   */\r\n  createForm(config: Omit<FormConfig, 'id'>): Observable<FormConfig> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!config.title) {\r\n      return throwError(() => new ValidationError('Form title is required'));\r\n    }\r\n\r\n    if (!config.fields || config.fields.length === 0) {\r\n      return throwError(() => new ValidationError('At least one field is required'));\r\n    }\r\n\r\n    return this.http.post<FormConfig>(\r\n      `${this.apiUrl}/api/forms`,\r\n      config,\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 existing form\r\n   */\r\n  updateForm(formId: string, config: Partial<FormConfig>): Observable<FormConfig> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!formId) {\r\n      return throwError(() => new ValidationError('Form ID is required'));\r\n    }\r\n\r\n    return this.http.put<FormConfig>(\r\n      `${this.apiUrl}/api/forms/${formId}`,\r\n      config,\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 form\r\n   */\r\n  deleteForm(formId: 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 (!formId) {\r\n      return throwError(() => new ValidationError('Form ID is required'));\r\n    }\r\n\r\n    return this.http.delete<void>(\r\n      `${this.apiUrl}/api/forms/${formId}`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get form analytics\r\n   */\r\n  getAnalytics(formId: string): Observable<any> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!formId) {\r\n      return throwError(() => new ValidationError('Form ID is required'));\r\n    }\r\n\r\n    return this.http.get<any>(\r\n      `${this.apiUrl}/api/forms/${formId}/analytics`,\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Publish a form\r\n   */\r\n  publishForm(formId: string, slug: string): Observable<{ publishedUrl: string; slug: string }> {\r\n    if (!this.apiKey) {\r\n      return throwError(() => new MetiganError('Service not initialized. Call initialize() first.'));\r\n    }\r\n\r\n    if (!formId) {\r\n      return throwError(() => new ValidationError('Form ID is required'));\r\n    }\r\n\r\n    if (!slug) {\r\n      return throwError(() => new ValidationError('Slug is required'));\r\n    }\r\n\r\n    return this.http.post<{ publishedUrl: string; slug: string }>(\r\n      `${this.apiUrl}/api/forms/${formId}/publish`,\r\n      { slug },\r\n      { headers: this.getHeaders() },\r\n      this.retryCount,\r\n      this.retryDelay\r\n    );\r\n  }\r\n}\r\n\r\n"]}