@tratto/angular 0.1.0

package/fesm2022/tratto-angular.mjs

@@ -0,0 +1,932 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, makeEnvironmentProviders, NgModule } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+
+/** DI injection token that holds the {@link TrattoConfig}. */
+const TRATTO_CONFIG = new InjectionToken('TRATTO_CONFIG');
+
+/**
+ * Abstract base class shared by all Tratto resource services.
+ * Provides the `HttpClient`, config injection, and auth-header helpers.
+ */
+class BaseService {
+    http = inject(HttpClient);
+    config = inject(TRATTO_CONFIG);
+    /** Root API URL without trailing slash (e.g. `https://api.tratto.email`). */
+    apiBaseUrl = (this.config.baseUrl ?? 'https://api.tratto.email').replace(/\/$/, '');
+    /**
+     * Returns an `HttpHeaders` instance pre-populated with the `Authorization` header.
+     * Pass `extra` to merge additional headers (e.g. `Idempotency-Key`).
+     */
+    authHeaders(extra) {
+        return new HttpHeaders({ Authorization: `Bearer ${this.config.apiKey}`, ...extra });
+    }
+    /**
+     * Builds an `HttpParams` object from a plain object, skipping `null`/`undefined` values.
+     * `Date` values are serialised to ISO strings.
+     */
+    buildParams(params) {
+        return Object.entries(params).reduce((p, [key, val]) => {
+            if (val == null)
+                return p;
+            if (val instanceof Date)
+                return p.set(key, val.toISOString());
+            return p.set(key, String(val));
+        }, new HttpParams());
+    }
+    /**
+     * RxJS operator that unwraps the `{ data: T }` envelope returned by every
+     * Tratto API endpoint.
+     */
+    unwrap() {
+        return map((r) => r.data);
+    }
+    /**
+     * Sends a DELETE/PATCH/POST that returns HTTP 204 (no body).
+     * Uses `responseType: 'text'` to avoid JSON-parse errors on an empty body.
+     */
+    voidRequest(method, url, body) {
+        return this.http
+            .request(method, url, {
+            headers: this.authHeaders(),
+            responseType: 'text',
+            ...(body !== undefined ? { body } : {}),
+        })
+            .pipe(map(() => void 0));
+    }
+}
+
+/** Service for sending transactional emails and inspecting their delivery. */
+class EmailsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/emails`;
+    /**
+     * Send a transactional email (`POST /v1/emails`).
+     * At least one of `html`, `text`, or `templateId` is required.
+     *
+     * @param params Email parameters.
+     * @param idempotencyKey Optional key that guarantees exactly-once delivery.
+     *   If the same key is re-used within 24 hours the original response is returned.
+     * @returns Observable that emits the created email `id`.
+     */
+    send(params, idempotencyKey) {
+        const headers = this.authHeaders(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined);
+        return this.http
+            .post(this.url, params, { headers })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List emails with optional filters (`GET /v1/emails`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({
+                after: params?.after,
+                limit: params?.limit,
+                status: params?.status,
+                domainId: params?.domainId,
+                tags: params?.tags,
+                dateFrom: params?.dateFrom,
+                dateTo: params?.dateTo,
+            }),
+        });
+    }
+    /**
+     * Get a single email with full details and inline events (`GET /v1/emails/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List all delivery events for a specific email (`GET /v1/emails/:id/events`).
+     */
+    listEvents(id) {
+        return this.http
+            .get(`${this.url}/${id}/events`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: EmailsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: EmailsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: EmailsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing contacts and running CSV imports. */
+class ContactsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/contacts`;
+    /**
+     * Create a single contact (`POST /v1/contacts`).
+     * Returns a conflict error if the email address is already registered.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List contacts with optional filters (`GET /v1/contacts`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({
+                status: params?.status,
+                audienceId: params?.audienceId,
+                tag: params?.tag,
+                after: params?.after,
+                limit: params?.limit,
+            }),
+        });
+    }
+    /**
+     * Update a contact's details (`PATCH /v1/contacts/:id`).
+     * Only supplied fields are updated.
+     */
+    update(id, params) {
+        return this.http
+            .patch(`${this.url}/${id}`, params, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Start an asynchronous CSV import job (`POST /v1/contacts/import`).
+     *
+     * The CSV must have an `email` column. Optional columns:
+     * `first_name` / `firstname`, `last_name` / `lastname`, `status`,
+     * `tags` (semicolon-separated values).
+     *
+     * Maximum 50 000 rows per import. Poll {@link getImportJob} to track progress.
+     *
+     * @returns Observable that emits the new `jobId` and total row count.
+     */
+    importCsv(csvText) {
+        return this.http
+            .post(`${this.url}/import`, csvText, {
+            headers: new HttpHeaders({
+                Authorization: `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'text/csv',
+            }),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Poll the status of a CSV import job (`GET /v1/contacts/import/:jobId`).
+     */
+    getImportJob(jobId) {
+        return this.http
+            .get(`${this.url}/import/${jobId}`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ContactsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ContactsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ContactsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing contact audiences. */
+class AudiencesService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/audiences`;
+    /**
+     * Create an audience (`POST /v1/audiences`).
+     * Optionally supply filter `rules` to make it a dynamic segment.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List audiences (`GET /v1/audiences`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Get a single audience by ID (`GET /v1/audiences/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Add contacts to an audience (`POST /v1/audiences/:id/contacts`).
+     * Accepts up to 500 contact IDs per call.
+     */
+    addContacts(audienceId, contactIds) {
+        return this.http
+            .post(`${this.url}/${audienceId}/contacts`, { contactIds }, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AudiencesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AudiencesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AudiencesService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing and sending email campaigns. */
+class CampaignsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/campaigns`;
+    /**
+     * Create a campaign in `draft` status (`POST /v1/campaigns`).
+     * Call {@link send} to dispatch it.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List campaigns with optional status filter (`GET /v1/campaigns`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ status: params?.status, after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Get a single campaign by ID (`GET /v1/campaigns/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Get delivery statistics for a campaign (`GET /v1/campaigns/:id/stats`).
+     */
+    getStats(id) {
+        return this.http
+            .get(`${this.url}/${id}/stats`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Send or schedule a campaign (`POST /v1/campaigns/:id/send`).
+     * Only `draft` or `paused` campaigns can be sent.
+     *
+     * @param id Campaign ID.
+     * @param params Optional `scheduledAt` to defer sending.
+     * @returns Observable emitting the new campaign status.
+     */
+    send(id, params) {
+        const body = {};
+        if (params?.scheduledAt) {
+            body['scheduledAt'] =
+                params.scheduledAt instanceof Date
+                    ? params.scheduledAt.toISOString()
+                    : params.scheduledAt;
+        }
+        return this.http
+            .post(`${this.url}/${id}/send`, body, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Pause a `sending` or `scheduled` campaign (`POST /v1/campaigns/:id/pause`).
+     */
+    pause(id) {
+        return this.http
+            .post(`${this.url}/${id}/pause`, {}, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Send a test email for this campaign to a specific address
+     * (`POST /v1/campaigns/:id/test-send`).
+     *
+     * @param id Campaign ID.
+     * @param to Recipient email address for the test.
+     * @returns Observable emitting the created test email ID.
+     */
+    testSend(id, to) {
+        return this.http
+            .post(`${this.url}/${id}/test-send`, { to }, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: CampaignsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: CampaignsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: CampaignsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing email templates and their version history. */
+class TemplatesService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/templates`;
+    /**
+     * List templates (`GET /v1/templates`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ limit: params?.limit, after: params?.after, status: params?.status }),
+        });
+    }
+    /**
+     * Create a new template (`POST /v1/templates`).
+     * The template starts in `draft` status.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Get a single template by ID (`GET /v1/templates/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Update a template's name, HTML, or status (`PATCH /v1/templates/:id`).
+     * Changing `html` automatically creates a new version entry.
+     */
+    update(id, params) {
+        return this.http
+            .patch(`${this.url}/${id}`, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Permanently delete a template (`DELETE /v1/templates/:id`).
+     */
+    delete(id) {
+        return this.voidRequest('DELETE', `${this.url}/${id}`);
+    }
+    /**
+     * List the version history of a template (`GET /v1/templates/:id/versions`).
+     * Returns up to the 20 most recent versions, newest first.
+     */
+    listVersions(id) {
+        return this.http
+            .get(`${this.url}/${id}/versions`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Get the HTML of a specific template version (`GET /v1/templates/:id/versions/:version`).
+     */
+    getVersion(id, version) {
+        return this.http
+            .get(`${this.url}/${id}/versions/${version}`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Send a test email using this template (`POST /v1/templates/:id/test-send`).
+     *
+     * @param id Template ID.
+     * @param to Recipient address for the test.
+     * @param variables Variables to substitute inside the template.
+     */
+    testSend(id, to, variables = {}) {
+        return this.http
+            .post(`${this.url}/${id}/test-send`, { to, variables }, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TemplatesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TemplatesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TemplatesService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing webhook endpoints and inspecting delivery history. */
+class WebhooksService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/webhooks`;
+    /**
+     * Register a new webhook endpoint (`POST /v1/webhooks`).
+     *
+     * The returned `secret` is shown only once — store it securely and use it
+     * to verify the `X-Tratto-Signature` header on incoming events.
+     *
+     * @returns Observable emitting the new webhook `id` and HMAC signing `secret`.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List all registered webhooks (`GET /v1/webhooks`).
+     * Results are ordered by creation date descending.
+     */
+    list() {
+        return this.http
+            .get(this.url, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Delete a webhook endpoint (`DELETE /v1/webhooks/:id`).
+     */
+    delete(id) {
+        return this.voidRequest('DELETE', `${this.url}/${id}`);
+    }
+    /**
+     * List delivery attempts for a webhook (`GET /v1/webhooks/:id/deliveries`).
+     * Results are ordered by attempt date descending.
+     */
+    listDeliveries(id, params) {
+        return this.http.get(`${this.url}/${id}/deliveries`, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Send a test event to a webhook endpoint (`POST /v1/webhooks/:id/test`).
+     * Useful for verifying connectivity and signature verification logic.
+     */
+    test(id) {
+        return this.http
+            .post(`${this.url}/${id}/test`, {}, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Rotate the signing secret for a webhook (`POST /v1/webhooks/:id/rotate-secret`).
+     * The new secret is returned once — store it securely.
+     * Also resets the failure counter and re-enables a disabled webhook.
+     */
+    rotateSecret(id) {
+        return this.http
+            .post(`${this.url}/${id}/rotate-secret`, {}, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WebhooksService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WebhooksService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WebhooksService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for adding and verifying sender domains. */
+class DomainsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/domains`;
+    /**
+     * Add a domain and generate its DKIM keypair (`POST /v1/domains`).
+     * The response contains the DNS records that must be published before calling {@link verify}.
+     *
+     * @param domain Bare domain name, e.g. `"mail.acme.com"`.
+     */
+    add(domain) {
+        return this.http
+            .post(this.url, { domain }, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List domains (`GET /v1/domains`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Get full domain details including DNS records (`GET /v1/domains/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Trigger DNS verification for a domain (`POST /v1/domains/:id/verify`).
+     * Checks SPF, DKIM, and DMARC records in real time and updates the domain status.
+     * The domain must be `verified` before it can be used as a sender.
+     */
+    verify(id) {
+        return this.http
+            .post(`${this.url}/${id}/verify`, {}, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Remove a domain and delete its DKIM private key (`DELETE /v1/domains/:id`).
+     *
+     * @returns Observable emitting the deleted domain `id` and `deletedAt` timestamp.
+     */
+    delete(id) {
+        return this.http
+            .delete(`${this.url}/${id}`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: DomainsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: DomainsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: DomainsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for creating and revoking API keys. */
+class ApiKeysService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/api-keys`;
+    /**
+     * Create a new API key (`POST /v1/api-keys`).
+     *
+     * The full raw key in the response is shown **only once** — store it securely.
+     *
+     * @param params Key name, environment and permission scopes.
+     * @param idempotencyKey Optional key to prevent accidental duplicates.
+     * @returns Observable emitting the created key including the raw token.
+     */
+    create(params, idempotencyKey) {
+        const headers = this.authHeaders(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined);
+        return this.http
+            .post(this.url, params, { headers })
+            .pipe(this.unwrap());
+    }
+    /**
+     * List API keys (without the raw token) (`GET /v1/api-keys`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Revoke (soft-delete) an API key (`DELETE /v1/api-keys/:id`).
+     * Revoked keys are immediately rejected by the API.
+     *
+     * @returns Observable emitting the key `id` and `revokedAt` timestamp.
+     */
+    revoke(id) {
+        return this.http
+            .delete(`${this.url}/${id}`, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ApiKeysService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ApiKeysService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: ApiKeysService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for querying email analytics and delivery metrics. */
+class AnalyticsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/analytics`;
+    /**
+     * Get aggregated email metrics for a time period (`GET /v1/analytics/summary`).
+     * Results are cached server-side for one hour.
+     *
+     * @param period Lookback window. Defaults to `'30d'`.
+     */
+    getSummary(period = '30d') {
+        return this.http
+            .get(`${this.url}/summary`, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ period }),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Get daily email metrics for a time period (`GET /v1/analytics/timeseries`).
+     * Returns one data point per day for the chosen window.
+     * Results are cached server-side for one hour.
+     *
+     * @param period Lookback window. Defaults to `'30d'`.
+     */
+    getTimeseries(period = '30d') {
+        return this.http
+            .get(`${this.url}/timeseries`, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ period }),
+        })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AnalyticsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AnalyticsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: AnalyticsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing email automation flows. */
+class FlowsService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/flows`;
+    /**
+     * List automation flows (`GET /v1/flows`).
+     * Results are ordered by creation date descending.
+     */
+    list(params) {
+        return this.http.get(this.url, {
+            headers: this.authHeaders(),
+            params: this.buildParams({ after: params?.after, limit: params?.limit }),
+        });
+    }
+    /**
+     * Create a flow in `draft` status (`POST /v1/flows`).
+     * Configure the trigger and steps via {@link update} before activating.
+     */
+    create(params) {
+        return this.http
+            .post(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Get a single flow by ID (`GET /v1/flows/:id`).
+     */
+    get(id) {
+        return this.http
+            .get(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Update a flow's name, trigger, or steps (`PATCH /v1/flows/:id`).
+     * Steps cannot be changed while the flow is active — call {@link deactivate} first.
+     */
+    update(id, params) {
+        return this.http
+            .patch(`${this.url}/${id}`, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Delete a flow (`DELETE /v1/flows/:id`).
+     * Only `draft` or `inactive` flows can be deleted.
+     */
+    delete(id) {
+        return this.http
+            .delete(`${this.url}/${id}`, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Activate a flow, enabling it to enroll contacts (`POST /v1/flows/:id/activate`).
+     */
+    activate(id) {
+        return this.http
+            .post(`${this.url}/${id}/activate`, {}, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Deactivate a flow (`POST /v1/flows/:id/deactivate`).
+     * Contacts already enrolled continue through their current steps.
+     * No new enrollments are accepted until the flow is re-activated.
+     */
+    deactivate(id) {
+        return this.http
+            .post(`${this.url}/${id}/deactivate`, {}, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: FlowsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: FlowsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: FlowsService, decorators: [{
+            type: Injectable
+        }] });
+
+/** Service for managing workspace settings and team members. */
+class WorkspaceService extends BaseService {
+    url = `${this.apiBaseUrl}/v1/workspace`;
+    /**
+     * Get the current workspace (`GET /v1/workspace`).
+     * Creates a workspace with default settings on first access if none exists.
+     */
+    get() {
+        return this.http
+            .get(this.url, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Update workspace settings (`PATCH /v1/workspace`).
+     * Only supplied fields are changed.
+     */
+    update(params) {
+        return this.http
+            .patch(this.url, params, { headers: this.authHeaders() })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Schedule the workspace for deletion (`DELETE /v1/workspace`).
+     * Only the workspace owner can perform this action.
+     */
+    delete() {
+        return this.voidRequest('DELETE', this.url);
+    }
+    /**
+     * Update workspace preferences such as locale and notification settings
+     * (`PATCH /v1/workspace/preferences`).
+     */
+    updatePreferences(params) {
+        return this.http
+            .patch(`${this.url}/preferences`, params, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Invite a new member to the workspace (`POST /v1/workspace/members/invite`).
+     * The invite is accepted automatically when the user first logs in.
+     */
+    inviteMember(params) {
+        return this.http
+            .post(`${this.url}/members/invite`, params, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Update a member's role (`PATCH /v1/workspace/members/:userId`).
+     */
+    updateMember(userId, params) {
+        return this.http
+            .patch(`${this.url}/members/${userId}`, params, {
+            headers: this.authHeaders(),
+        })
+            .pipe(this.unwrap());
+    }
+    /**
+     * Remove a member from the workspace (`DELETE /v1/workspace/members/:userId`).
+     * The workspace owner cannot be removed.
+     */
+    removeMember(userId) {
+        return this.voidRequest('DELETE', `${this.url}/members/${userId}`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WorkspaceService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WorkspaceService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: WorkspaceService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Top-level facade that aggregates all Tratto resource services.
+ *
+ * Inject `TrattoService` for a single entry-point into the SDK, or inject
+ * individual resource services (e.g. `EmailsService`) directly for
+ * better tree-shaking in large applications.
+ *
+ * @example
+ * ```ts
+ * // app.component.ts
+ * export class AppComponent {
+ *   private tratto = inject(TrattoService);
+ *
+ *   sendWelcome() {
+ *     this.tratto.emails
+ *       .send({ from: 'hello@acme.com', to: 'user@example.com', subject: 'Welcome!' })
+ *       .subscribe(({ id }) => console.log('Sent:', id));
+ *   }
+ * }
+ * ```
+ */
+class TrattoService {
+    /** Access email sending and inspection methods. */
+    emails = inject(EmailsService);
+    /** Access contact management and CSV import methods. */
+    contacts = inject(ContactsService);
+    /** Access audience creation and membership methods. */
+    audiences = inject(AudiencesService);
+    /** Access campaign creation, scheduling, and statistics methods. */
+    campaigns = inject(CampaignsService);
+    /** Access template CRUD and version history methods. */
+    templates = inject(TemplatesService);
+    /** Access webhook registration and delivery history methods. */
+    webhooks = inject(WebhooksService);
+    /** Access domain onboarding and DNS verification methods. */
+    domains = inject(DomainsService);
+    /** Access API key creation and revocation methods. */
+    apiKeys = inject(ApiKeysService);
+    /** Access email analytics summary and time-series methods. */
+    analytics = inject(AnalyticsService);
+    /** Access automation flow management methods. */
+    flows = inject(FlowsService);
+    /** Access workspace settings and team member methods. */
+    workspace = inject(WorkspaceService);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoService, decorators: [{
+            type: Injectable
+        }] });
+
+/** All injectable services exported by this SDK. */
+const TRATTO_PROVIDERS = [
+    EmailsService,
+    ContactsService,
+    AudiencesService,
+    CampaignsService,
+    TemplatesService,
+    WebhooksService,
+    DomainsService,
+    ApiKeysService,
+    AnalyticsService,
+    FlowsService,
+    WorkspaceService,
+    TrattoService,
+];
+/**
+ * Provides all Tratto services for **standalone** Angular applications.
+ *
+ * Add this to your `ApplicationConfig` providers array alongside
+ * `provideHttpClient()`. The SDK uses `HttpClient` internally; if your app
+ * has not already provided it, include `provideHttpClient()` as well.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * import { provideHttpClient } from '@angular/common/http';
+ * import { provideTratt } from '@tratto/angular';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(),
+ *     provideTratt({ apiKey: 'tratto_live_...' }),
+ *   ],
+ * };
+ * ```
+ */
+function provideTratt(config) {
+    return makeEnvironmentProviders([
+        { provide: TRATTO_CONFIG, useValue: config },
+        ...TRATTO_PROVIDERS,
+    ]);
+}
+/**
+ * Angular module that registers all Tratto services.
+ *
+ * For Angular 14+ **standalone** applications prefer {@link provideTratt}.
+ * For **NgModule**-based applications use `TrattoModule.forRoot()`.
+ *
+ * > **Note:** `HttpClientModule` (or `provideHttpClient()`) must be imported
+ * > in your application before importing `TrattoModule`.
+ *
+ * @example
+ * ```ts
+ * // app.module.ts
+ * import { HttpClientModule } from '@angular/common/http';
+ * import { TrattoModule } from '@tratto/angular';
+ *
+ * @NgModule({
+ *   imports: [
+ *     HttpClientModule,
+ *     TrattoModule.forRoot({ apiKey: 'tratto_live_...' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+class TrattoModule {
+    static forRoot(config) {
+        return {
+            ngModule: TrattoModule,
+            providers: [
+                { provide: TRATTO_CONFIG, useValue: config },
+                ...TRATTO_PROVIDERS,
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.3", ngImport: i0, type: TrattoModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.3", ngImport: i0, type: TrattoModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+
+// ── Configuration ─────────────────────────────────────────────────────────────
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnalyticsService, ApiKeysService, AudiencesService, CampaignsService, ContactsService, DomainsService, EmailsService, FlowsService, TRATTO_CONFIG, TemplatesService, TrattoModule, TrattoService, WebhooksService, WorkspaceService, provideTratt };
+//# sourceMappingURL=tratto-angular.mjs.map