@adtrackify/at-service-common 3.19.25 → 4.0.1

package/dist/esm/services/db/user-accounts-db-service.d.ts

@@ -1,7 +1,7 @@
-import { type UserAccountRecord } from '@adtrackify/at-tracking-event-types';
-export declare class UserAccountsDbService {
-    TABLE_NAME: string;
-    TABLE_KEY: string;
-    constructor(tableName: string, tableKey?: string);
-    batchGetByAccountIds: (indexName: string, accountIdKey: string, accountIds: string[], concurrency?: number) => Promise<UserAccountRecord[]>;
-}
+import { type UserAccountRecord } from '@adtrackify/at-tracking-event-types';
+export declare class UserAccountsDbService {
+    TABLE_NAME: string;
+    TABLE_KEY: string;
+    constructor(tableName: string, tableKey?: string);
+    batchGetByAccountIds: (indexName: string, accountIdKey: string, accountIds: string[], concurrency?: number) => Promise<UserAccountRecord[]>;
+}

package/dist/esm/services/db/user-accounts-db-service.js

@@ -1,14 +1,14 @@
-import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
-export class UserAccountsDbService {
-    TABLE_NAME;
-    TABLE_KEY;
-    constructor(tableName, tableKey = 'userId') {
-        this.TABLE_NAME = tableName;
-        this.TABLE_KEY = tableKey;
-    }
-    batchGetByAccountIds = async (indexName, accountIdKey, accountIds, concurrency = 10) => {
-        const records = await DynamoDbClient.safeBatchQueryByGSI(this.TABLE_NAME, indexName, accountIdKey, accountIds, concurrency);
-        return records;
-    };
-}
+import { DynamoDbClient } from '../../clients/generic/dynamodb-client.js';
+export class UserAccountsDbService {
+    TABLE_NAME;
+    TABLE_KEY;
+    constructor(tableName, tableKey = 'userId') {
+        this.TABLE_NAME = tableName;
+        this.TABLE_KEY = tableKey;
+    }
+    batchGetByAccountIds = async (indexName, accountIdKey, accountIds, concurrency = 10) => {
+        const records = await DynamoDbClient.safeBatchQueryByGSI(this.TABLE_NAME, indexName, accountIdKey, accountIds, concurrency);
+        return records;
+    };
+}
 //# sourceMappingURL=user-accounts-db-service.js.map

package/dist/esm/services/email-verification/contact-email-verification-service.d.ts

@@ -1,7 +1,7 @@
-import { EmailableVerifyEmailResponse, ThirdPartyContact } from '@adtrackify/at-tracking-event-types';
-export declare class ContactEmailVerificationService {
-    private emailVerificationService;
-    constructor(cacheLambdaFunctionArn: string, emailableApiKey: string);
-    verifyContactEmail: (contact: ThirdPartyContact, email: string, forceVerify?: boolean) => Promise<EmailableVerifyEmailResponse | null>;
-    verifyContactsEmail: (contacts: ThirdPartyContact[]) => Promise<ThirdPartyContact[] | null>;
-}
+import { EmailableVerifyEmailResponse, ThirdPartyContact } from '@adtrackify/at-tracking-event-types';
+export declare class ContactEmailVerificationService {
+    private emailVerificationService;
+    constructor(cacheLambdaFunctionArn: string, emailableApiKey: string);
+    verifyContactEmail: (contact: ThirdPartyContact, email: string, forceVerify?: boolean) => Promise<EmailableVerifyEmailResponse | null>;
+    verifyContactsEmail: (contacts: ThirdPartyContact[]) => Promise<ThirdPartyContact[] | null>;
+}

package/dist/esm/services/email-verification/contact-email-verification-service.js

@@ -1,98 +1,98 @@
-import { EMAIL_STATUS } from '@adtrackify/at-tracking-event-types';
-import { Logger } from '../../helpers';
-import { isBlacklistedEmail, isDisposableEmail, isYahooEmail, validateEmail } from '../../libs/emails.js';
-import { EmailVerificationService } from './email-verification-service.js';
-export class ContactEmailVerificationService {
-    emailVerificationService;
-    constructor(cacheLambdaFunctionArn, emailableApiKey) {
-        this.emailVerificationService = new EmailVerificationService(cacheLambdaFunctionArn, emailableApiKey);
-    }
-    verifyContactEmail = async (contact, email, forceVerify = false) => {
-        try {
-            if (!validateEmail(email)) {
-                Logger.error('contact acquisition - Email is invalid', { contact, email });
-                return null;
-            }
-            if (isBlacklistedEmail(email)) {
-                Logger.error('contact acquisition - Email is a blacklisted email', { contact, email });
-                return null;
-            }
-            if (isDisposableEmail(email)) {
-                Logger.error('contact acquisition - Email is a disposable email', { contact, email });
-                return null;
-            }
-            if (isYahooEmail(email) && !forceVerify) {
-                Logger.info('contact acquisition - Email is a yahoo email', { contact, email });
-                const emailVerification = {
-                    state: EMAIL_STATUS.RISKY,
-                    email: email,
-                    reason: 'Yahoo email - riskier than other emails',
-                };
-                return emailVerification;
-            }
-            const emailVerificationResponse = await this.emailVerificationService.getEmailVerificationWithCaching(email);
-            if (!emailVerificationResponse || !emailVerificationResponse.emailVerification) {
-                Logger.error('contact acquisition - No response from email verification service', {
-                    contact,
-                    email,
-                    emailVerificationResponse,
-                });
-                return null;
-            }
-            Logger.info('contact acquisition - Email verification response', { contact, email, emailVerificationResponse });
-            const emailVerification = emailVerificationResponse.emailVerification;
-            if (emailVerification.state === EMAIL_STATUS.DELIVERABLE) {
-                Logger.info('contact acquisition - Email verification is deliverable', { contact, email, emailVerification });
-                return emailVerification;
-            }
-            if (emailVerification.state === EMAIL_STATUS.RISKY) {
-                Logger.warn('contact acquisition - Email verification is risky', { contact, email, emailVerification });
-                return emailVerification;
-            }
-            if (emailVerification.state === EMAIL_STATUS.UNDELIVERABLE) {
-                Logger.warn('contact acquisition - Email verification is undeliverable', { contact, email, emailVerification });
-                return emailVerification;
-            }
-            if (emailVerification.state === EMAIL_STATUS.UNKNOWN) {
-                Logger.warn('contact acquisition - Email verification is unknown', { contact, email, emailVerification });
-                return emailVerification;
-            }
-            if (emailVerification.state === EMAIL_STATUS.NO_EMAIL) {
-                Logger.warn('contact acquisition - Email verification is no email', { contact, email, emailVerification });
-                return emailVerification;
-            }
-            Logger.info('contact acquisition - Email verification', { contact, email, emailVerification });
-            return emailVerification;
-        }
-        catch (error) {
-            Logger.error('contact acquisition - Failed to verify contact email', { error });
-            return null;
-        }
-    };
-    verifyContactsEmail = async (contacts) => {
-        try {
-            const verifiedContacts = [];
-            for (let i = 0; i < contacts.length; i++) {
-                const contact = contacts[i];
-                const email = contact.emailAddress;
-                if (email) {
-                    const emailVerification = await this.verifyContactEmail(contact, email);
-                    if (emailVerification) {
-                        contact.emailVerification = emailVerification;
-                        verifiedContacts.push(contact);
-                    }
-                }
-                else {
-                    Logger.warn('contact acquisition - No email found for contact -- skipping', { contact });
-                    continue;
-                }
-            }
-            return verifiedContacts;
-        }
-        catch (error) {
-            Logger.error('contact acquisition - Failed to verify contact emails', { error });
-            return null;
-        }
-    };
-}
+import { EMAIL_STATUS } from '@adtrackify/at-tracking-event-types';
+import { Logger } from '../../helpers';
+import { isBlacklistedEmail, isDisposableEmail, isYahooEmail, validateEmail } from '../../libs/emails.js';
+import { EmailVerificationService } from './email-verification-service.js';
+export class ContactEmailVerificationService {
+    emailVerificationService;
+    constructor(cacheLambdaFunctionArn, emailableApiKey) {
+        this.emailVerificationService = new EmailVerificationService(cacheLambdaFunctionArn, emailableApiKey);
+    }
+    verifyContactEmail = async (contact, email, forceVerify = false) => {
+        try {
+            if (!validateEmail(email)) {
+                Logger.error('contact acquisition - Email is invalid', { contact, email });
+                return null;
+            }
+            if (isBlacklistedEmail(email)) {
+                Logger.error('contact acquisition - Email is a blacklisted email', { contact, email });
+                return null;
+            }
+            if (isDisposableEmail(email)) {
+                Logger.error('contact acquisition - Email is a disposable email', { contact, email });
+                return null;
+            }
+            if (isYahooEmail(email) && !forceVerify) {
+                Logger.info('contact acquisition - Email is a yahoo email', { contact, email });
+                const emailVerification = {
+                    state: EMAIL_STATUS.RISKY,
+                    email: email,
+                    reason: 'Yahoo email - riskier than other emails',
+                };
+                return emailVerification;
+            }
+            const emailVerificationResponse = await this.emailVerificationService.getEmailVerificationWithCaching(email);
+            if (!emailVerificationResponse || !emailVerificationResponse.emailVerification) {
+                Logger.error('contact acquisition - No response from email verification service', {
+                    contact,
+                    email,
+                    emailVerificationResponse,
+                });
+                return null;
+            }
+            Logger.info('contact acquisition - Email verification response', { contact, email, emailVerificationResponse });
+            const emailVerification = emailVerificationResponse.emailVerification;
+            if (emailVerification.state === EMAIL_STATUS.DELIVERABLE) {
+                Logger.info('contact acquisition - Email verification is deliverable', { contact, email, emailVerification });
+                return emailVerification;
+            }
+            if (emailVerification.state === EMAIL_STATUS.RISKY) {
+                Logger.warn('contact acquisition - Email verification is risky', { contact, email, emailVerification });
+                return emailVerification;
+            }
+            if (emailVerification.state === EMAIL_STATUS.UNDELIVERABLE) {
+                Logger.warn('contact acquisition - Email verification is undeliverable', { contact, email, emailVerification });
+                return emailVerification;
+            }
+            if (emailVerification.state === EMAIL_STATUS.UNKNOWN) {
+                Logger.warn('contact acquisition - Email verification is unknown', { contact, email, emailVerification });
+                return emailVerification;
+            }
+            if (emailVerification.state === EMAIL_STATUS.NO_EMAIL) {
+                Logger.warn('contact acquisition - Email verification is no email', { contact, email, emailVerification });
+                return emailVerification;
+            }
+            Logger.info('contact acquisition - Email verification', { contact, email, emailVerification });
+            return emailVerification;
+        }
+        catch (error) {
+            Logger.error('contact acquisition - Failed to verify contact email', { error });
+            return null;
+        }
+    };
+    verifyContactsEmail = async (contacts) => {
+        try {
+            const verifiedContacts = [];
+            for (let i = 0; i < contacts.length; i++) {
+                const contact = contacts[i];
+                const email = contact.emailAddress;
+                if (email) {
+                    const emailVerification = await this.verifyContactEmail(contact, email);
+                    if (emailVerification) {
+                        contact.emailVerification = emailVerification;
+                        verifiedContacts.push(contact);
+                    }
+                }
+                else {
+                    Logger.warn('contact acquisition - No email found for contact -- skipping', { contact });
+                    continue;
+                }
+            }
+            return verifiedContacts;
+        }
+        catch (error) {
+            Logger.error('contact acquisition - Failed to verify contact emails', { error });
+            return null;
+        }
+    };
+}
 //# sourceMappingURL=contact-email-verification-service.js.map

package/dist/esm/services/email-verification/email-verification-service.d.ts

@@ -1,19 +1,19 @@
-import { EmailableVerifyEmailResponse } from '@adtrackify/at-tracking-event-types';
-export interface EmailVerificationCache {
-    email: string;
-    emailVerification: EmailableVerifyEmailResponse;
-    createdAt?: string;
-    updatedAt: string;
-    expiresAt?: number;
-}
-export declare class EmailVerificationService {
-    private cacheLambdaClient;
-    private emailableClient;
-    constructor(cacheLambdaFunctionArn: string, emailableApiKey: string);
-    getEmailVerificationWithCaching: (email: string) => Promise<EmailVerificationCache | undefined>;
-    getEmailVerificationFromCache(email: string): Promise<EmailVerificationCache | undefined>;
-    deleteEmailVerificationCache(email: string): Promise<void>;
-    setEmailVerificationCache(email: string, emailVerificationCache: EmailVerificationCache): Promise<void>;
-    private getEmailVerificationCache;
-    private verifyEmail;
-}
+import { EmailableVerifyEmailResponse } from '@adtrackify/at-tracking-event-types';
+export interface EmailVerificationCache {
+    email: string;
+    emailVerification: EmailableVerifyEmailResponse;
+    createdAt?: string;
+    updatedAt: string;
+    expiresAt?: number;
+}
+export declare class EmailVerificationService {
+    private cacheLambdaClient;
+    private emailableClient;
+    constructor(cacheLambdaFunctionArn: string, emailableApiKey: string);
+    getEmailVerificationWithCaching: (email: string) => Promise<EmailVerificationCache | undefined>;
+    getEmailVerificationFromCache(email: string): Promise<EmailVerificationCache | undefined>;
+    deleteEmailVerificationCache(email: string): Promise<void>;
+    setEmailVerificationCache(email: string, emailVerificationCache: EmailVerificationCache): Promise<void>;
+    private getEmailVerificationCache;
+    private verifyEmail;
+}

package/dist/esm/services/email-verification/email-verification-service.js

@@ -1,128 +1,128 @@
-import { CacheLambdaClient } from '../../clients/internal-api/cache-lambda-client.js';
-import { EmailableClient } from '../../clients/third-party/emailable-client.js';
-import { Logger } from '../../helpers';
-import { getCurrentTimestamp } from '../../libs/dates.js';
-const EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
-export class EmailVerificationService {
-    cacheLambdaClient;
-    emailableClient;
-    constructor(cacheLambdaFunctionArn, emailableApiKey) {
-        this.cacheLambdaClient = new CacheLambdaClient(cacheLambdaFunctionArn);
-        this.emailableClient = new EmailableClient(emailableApiKey);
-    }
-    getEmailVerificationWithCaching = async (email) => {
-        try {
-            let shouldUpdateCache = false;
-            if (!email) {
-                Logger.error('getEmailVerificationWithCaching -No email', { email });
-                return undefined;
-            }
-            let cacheResponse = await this.getEmailVerificationFromCache(email);
-            if (cacheResponse && cacheResponse?.emailVerification) {
-                Logger.info('email verification cache hit', { email, cacheResponse });
-                return cacheResponse;
-            }
-            Logger.info('email verification cache miss - fetching from emailable api service', { email });
-            const emailVerification = await this.verifyEmail(email);
-            if (emailVerification) {
-                const emailVerificationCache = {
-                    email,
-                    emailVerification,
-                    createdAt: getCurrentTimestamp(),
-                    updatedAt: getCurrentTimestamp(),
-                    expiresAt: Date.now() + EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS * 1000,
-                };
-                shouldUpdateCache = true;
-                cacheResponse = emailVerificationCache;
-            }
-            else {
-                Logger.error('Failed to getEmailVerification from emailable api service', { email, emailVerification });
-                return undefined;
-            }
-            if (cacheResponse && shouldUpdateCache) {
-                await this.setEmailVerificationCache(email, cacheResponse);
-            }
-            return cacheResponse;
-        }
-        catch (error) {
-            Logger.error('Error while getting email verification with caching', { error, email });
-            return undefined;
-        }
-    };
-    async getEmailVerificationFromCache(email) {
-        try {
-            if (!email) {
-                return undefined;
-            }
-            const cacheKey = `emailVerification_${email}`;
-            Logger.info(' try email verification cache lookup with email', { cacheKey, email });
-            const cachedEmailVerificationResponse = await this.getEmailVerificationCache(cacheKey);
-            if (!cachedEmailVerificationResponse) {
-                return undefined;
-            }
-            Logger.info(' found cached email verification', { email, cacheKey, cachedEmailVerificationResponse });
-            return cachedEmailVerificationResponse;
-        }
-        catch (err) {
-            Logger.error('Error while getting email verification from cache', { err, email });
-            return undefined;
-        }
-    }
-    async deleteEmailVerificationCache(email) {
-        try {
-            if (!email) {
-                return;
-            }
-            const deleteCacheCommands = [];
-            deleteCacheCommands.push({
-                cacheKey: `emailVerification_${email}`,
-                commandType: 'delete',
-            });
-            await this.cacheLambdaClient.batchInvoke(deleteCacheCommands);
-        }
-        catch (err) {
-            Logger.error('Error while deleting email verification cache', { err, email });
-        }
-    }
-    async setEmailVerificationCache(email, emailVerificationCache) {
-        try {
-            if (!email || !emailVerificationCache) {
-                return;
-            }
-            const cacheKey = `emailVerification_${email}`;
-            Logger.info('setEmailVerificationCache', { email, emailVerificationCache });
-            await this.cacheLambdaClient.invokeSet(cacheKey, JSON.stringify(emailVerificationCache), EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS);
-        }
-        catch (error) {
-            Logger.error('Error while updating email verification cache redis', { error, email, emailVerificationCache });
-        }
-    }
-    getEmailVerificationCache = async (cacheKey) => {
-        const start = performance.now();
-        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
-        const end = performance.now();
-        Logger.info('getEmailVerificationCache', { cacheKey, cacheResponse, duration: end - start });
-        if (cacheResponse && cacheResponse.responseData) {
-            return cacheResponse.responseData;
-        }
-        return undefined;
-    };
-    verifyEmail = async (email) => {
-        try {
-            const emailVerificationResponse = await this.emailableClient.verifyEmail(email);
-            if (emailVerificationResponse.status === 200) {
-                const emailVerification = emailVerificationResponse?.data;
-                return emailVerification;
-            }
-            else {
-                Logger.error('EmailableApiService - returned failure status', { emailVerificationResponse });
-                return null;
-            }
-        }
-        catch (error) {
-            Logger.error('EmailableApiService - Failed to verify email', { error });
-            return null;
-        }
-    };
-}
+import { CacheLambdaClient } from '../../clients/internal-api/cache-lambda-client.js';
+import { EmailableClient } from '../../clients/third-party/emailable-client.js';
+import { Logger } from '../../helpers';
+import { getCurrentTimestamp } from '../../libs/dates.js';
+const EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
+export class EmailVerificationService {
+    cacheLambdaClient;
+    emailableClient;
+    constructor(cacheLambdaFunctionArn, emailableApiKey) {
+        this.cacheLambdaClient = new CacheLambdaClient(cacheLambdaFunctionArn);
+        this.emailableClient = new EmailableClient(emailableApiKey);
+    }
+    getEmailVerificationWithCaching = async (email) => {
+        try {
+            let shouldUpdateCache = false;
+            if (!email) {
+                Logger.error('getEmailVerificationWithCaching -No email', { email });
+                return undefined;
+            }
+            let cacheResponse = await this.getEmailVerificationFromCache(email);
+            if (cacheResponse && cacheResponse?.emailVerification) {
+                Logger.info('email verification cache hit', { email, cacheResponse });
+                return cacheResponse;
+            }
+            Logger.info('email verification cache miss - fetching from emailable api service', { email });
+            const emailVerification = await this.verifyEmail(email);
+            if (emailVerification) {
+                const emailVerificationCache = {
+                    email,
+                    emailVerification,
+                    createdAt: getCurrentTimestamp(),
+                    updatedAt: getCurrentTimestamp(),
+                    expiresAt: Date.now() + EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS * 1000,
+                };
+                shouldUpdateCache = true;
+                cacheResponse = emailVerificationCache;
+            }
+            else {
+                Logger.error('Failed to getEmailVerification from emailable api service', { email, emailVerification });
+                return undefined;
+            }
+            if (cacheResponse && shouldUpdateCache) {
+                await this.setEmailVerificationCache(email, cacheResponse);
+            }
+            return cacheResponse;
+        }
+        catch (error) {
+            Logger.error('Error while getting email verification with caching', { error, email });
+            return undefined;
+        }
+    };
+    async getEmailVerificationFromCache(email) {
+        try {
+            if (!email) {
+                return undefined;
+            }
+            const cacheKey = `emailVerification_${email}`;
+            Logger.info(' try email verification cache lookup with email', { cacheKey, email });
+            const cachedEmailVerificationResponse = await this.getEmailVerificationCache(cacheKey);
+            if (!cachedEmailVerificationResponse) {
+                return undefined;
+            }
+            Logger.info(' found cached email verification', { email, cacheKey, cachedEmailVerificationResponse });
+            return cachedEmailVerificationResponse;
+        }
+        catch (err) {
+            Logger.error('Error while getting email verification from cache', { err, email });
+            return undefined;
+        }
+    }
+    async deleteEmailVerificationCache(email) {
+        try {
+            if (!email) {
+                return;
+            }
+            const deleteCacheCommands = [];
+            deleteCacheCommands.push({
+                cacheKey: `emailVerification_${email}`,
+                commandType: 'delete',
+            });
+            await this.cacheLambdaClient.batchInvoke(deleteCacheCommands);
+        }
+        catch (err) {
+            Logger.error('Error while deleting email verification cache', { err, email });
+        }
+    }
+    async setEmailVerificationCache(email, emailVerificationCache) {
+        try {
+            if (!email || !emailVerificationCache) {
+                return;
+            }
+            const cacheKey = `emailVerification_${email}`;
+            Logger.info('setEmailVerificationCache', { email, emailVerificationCache });
+            await this.cacheLambdaClient.invokeSet(cacheKey, JSON.stringify(emailVerificationCache), EMAIL_VERIFICATION_CACHE_TTL_IN_SECONDS);
+        }
+        catch (error) {
+            Logger.error('Error while updating email verification cache redis', { error, email, emailVerificationCache });
+        }
+    }
+    getEmailVerificationCache = async (cacheKey) => {
+        const start = performance.now();
+        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
+        const end = performance.now();
+        Logger.info('getEmailVerificationCache', { cacheKey, cacheResponse, duration: end - start });
+        if (cacheResponse && cacheResponse.responseData) {
+            return cacheResponse.responseData;
+        }
+        return undefined;
+    };
+    verifyEmail = async (email) => {
+        try {
+            const emailVerificationResponse = await this.emailableClient.verifyEmail(email);
+            if (emailVerificationResponse.status === 200) {
+                const emailVerification = emailVerificationResponse?.data;
+                return emailVerification;
+            }
+            else {
+                Logger.error('EmailableApiService - returned failure status', { emailVerificationResponse });
+                return null;
+            }
+        }
+        catch (error) {
+            Logger.error('EmailableApiService - Failed to verify email', { error });
+            return null;
+        }
+    };
+}
 //# sourceMappingURL=email-verification-service.js.map

package/dist/esm/services/email-verification/index.d.ts

@@ -1,2 +1,2 @@
-export * from './email-verification-service.js';
-export * from './contact-email-verification-service.js';
+export * from './email-verification-service.js';
+export * from './contact-email-verification-service.js';

package/dist/esm/services/email-verification/index.js

@@ -1,3 +1,3 @@
-export * from './email-verification-service.js';
-export * from './contact-email-verification-service.js';
+export * from './email-verification-service.js';
+export * from './contact-email-verification-service.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/services/eventbridge-integration-service.d.ts

@@ -1,9 +1,9 @@
-import { EventBridgeClient } from '../clients/generic/eventbridge-client.js';
-import { Message, TemplatedMessage } from 'postmark';
-export declare class EventBridgeIntegrationService {
-    eventBridgeClient: EventBridgeClient;
-    EVENT_BUS_NAME: string;
-    constructor(eventBusName: string);
-    sendPostmarkEmailEvent: (eventSource: string, postmarkMessage: Message, postmarkServerToken: string) => Promise<import("@aws-sdk/client-eventbridge").PutEventsCommandOutput>;
-    sendPostmarkTemplatedEmailEvent: (eventSource: string, postmarkMessage: TemplatedMessage, postmarkServerToken: string) => Promise<import("@aws-sdk/client-eventbridge").PutEventsCommandOutput>;
-}
+import { EventBridgeClient } from '../clients/generic/eventbridge-client.js';
+import { Message, TemplatedMessage } from 'postmark';
+export declare class EventBridgeIntegrationService {
+    eventBridgeClient: EventBridgeClient;
+    EVENT_BUS_NAME: string;
+    constructor(eventBusName: string);
+    sendPostmarkEmailEvent: (eventSource: string, postmarkMessage: Message, postmarkServerToken: string) => Promise<import("@aws-sdk/client-eventbridge").PutEventsCommandOutput>;
+    sendPostmarkTemplatedEmailEvent: (eventSource: string, postmarkMessage: TemplatedMessage, postmarkServerToken: string) => Promise<import("@aws-sdk/client-eventbridge").PutEventsCommandOutput>;
+}

package/dist/esm/services/eventbridge-integration-service.js

@@ -1,25 +1,25 @@
-import { EventBridgeClient } from '../clients/generic/eventbridge-client.js';
-import { ADTRACKIFY_EVENT_BRIDGE_EVENTS, PostmarkRequestType } from '../types/internal-events/event-detail-types.js';
-export class EventBridgeIntegrationService {
-    eventBridgeClient;
-    EVENT_BUS_NAME;
-    constructor(eventBusName) {
-        this.eventBridgeClient = new EventBridgeClient(eventBusName);
-        this.EVENT_BUS_NAME = eventBusName;
-    }
-    sendPostmarkEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
-        return await this.eventBridgeClient.buildAndSendEvent(eventSource, ADTRACKIFY_EVENT_BRIDGE_EVENTS.SEND_POSTMARK_EMAIL, {
-            postmarkMessage,
-            postmarkRequestType: PostmarkRequestType.SINGLE_EMAIL,
-            postmarkServerToken,
-        });
-    };
-    sendPostmarkTemplatedEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
-        return await this.eventBridgeClient.buildAndSendEvent(eventSource, ADTRACKIFY_EVENT_BRIDGE_EVENTS.SEND_POSTMARK_EMAIL, {
-            postmarkMessage,
-            postmarkRequestType: PostmarkRequestType.TEMPLATE_EMAIL,
-            postmarkServerToken,
-        });
-    };
-}
+import { EventBridgeClient } from '../clients/generic/eventbridge-client.js';
+import { ADTRACKIFY_EVENT_BRIDGE_EVENTS, PostmarkRequestType } from '../types/internal-events/event-detail-types.js';
+export class EventBridgeIntegrationService {
+    eventBridgeClient;
+    EVENT_BUS_NAME;
+    constructor(eventBusName) {
+        this.eventBridgeClient = new EventBridgeClient(eventBusName);
+        this.EVENT_BUS_NAME = eventBusName;
+    }
+    sendPostmarkEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
+        return await this.eventBridgeClient.buildAndSendEvent(eventSource, ADTRACKIFY_EVENT_BRIDGE_EVENTS.SEND_POSTMARK_EMAIL, {
+            postmarkMessage,
+            postmarkRequestType: PostmarkRequestType.SINGLE_EMAIL,
+            postmarkServerToken,
+        });
+    };
+    sendPostmarkTemplatedEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
+        return await this.eventBridgeClient.buildAndSendEvent(eventSource, ADTRACKIFY_EVENT_BRIDGE_EVENTS.SEND_POSTMARK_EMAIL, {
+            postmarkMessage,
+            postmarkRequestType: PostmarkRequestType.TEMPLATE_EMAIL,
+            postmarkServerToken,
+        });
+    };
+}
 //# sourceMappingURL=eventbridge-integration-service.js.map