@vicacha-devs/strapi-plugin-broadcasts 0.0.0-stage → 0.1.0

package/dist/server/src/index.d.ts

@@ -0,0 +1,463 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    config: {
+        default: import('../../shared').BroadcastSettings;
+        validator(): void;
+    };
+    contentTypes: {
+        campaign: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    title: {
+                        type: string;
+                        required: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        targetField: string;
+                        required: boolean;
+                    };
+                    topic: {
+                        type: string;
+                        default: string;
+                        required: boolean;
+                    };
+                    channels: {
+                        type: string;
+                        required: boolean;
+                        default: string[];
+                    };
+                    priority: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        required: boolean;
+                    };
+                    status: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        required: boolean;
+                    };
+                    scheduledAt: {
+                        type: string;
+                    };
+                    sentAt: {
+                        type: string;
+                    };
+                    subject: {
+                        type: string;
+                        required: boolean;
+                    };
+                    bodyText: {
+                        type: string;
+                        required: boolean;
+                    };
+                    bodyHtml: {
+                        type: string;
+                    };
+                    ctaLabel: {
+                        type: string;
+                    };
+                    ctaUrl: {
+                        type: string;
+                    };
+                    mediaUrl: {
+                        type: string;
+                    };
+                    emailTemplateRef: {
+                        type: string;
+                    };
+                    whatsappTemplateName: {
+                        type: string;
+                    };
+                    whatsappGroupIds: {
+                        type: string;
+                        default: never[];
+                    };
+                    telegramChatId: {
+                        type: string;
+                    };
+                    telegramThreadId: {
+                        type: string;
+                    };
+                    translations: {
+                        type: string;
+                        default: {};
+                    };
+                    secondaryDate: {
+                        type: string;
+                        default: {};
+                    };
+                    secondaryDateLabel: {
+                        type: string;
+                    };
+                    stats: {
+                        type: string;
+                        default: {};
+                    };
+                    metadata: {
+                        type: string;
+                        default: {};
+                    };
+                };
+            };
+        };
+        "automation-rule": {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        targetField: string;
+                        required: boolean;
+                    };
+                    eventName: {
+                        type: string;
+                        required: boolean;
+                    };
+                    targetContentType: {
+                        type: string;
+                    };
+                    topic: {
+                        type: string;
+                        default: string;
+                        required: boolean;
+                    };
+                    channels: {
+                        type: string;
+                        required: boolean;
+                        default: string[];
+                    };
+                    active: {
+                        type: string;
+                        default: boolean;
+                    };
+                    priority: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    subjectTemplate: {
+                        type: string;
+                        required: boolean;
+                    };
+                    bodyTextTemplate: {
+                        type: string;
+                        required: boolean;
+                    };
+                    bodyHtmlTemplate: {
+                        type: string;
+                    };
+                    ctaLabelTemplate: {
+                        type: string;
+                    };
+                    ctaUrlTemplate: {
+                        type: string;
+                    };
+                    translations: {
+                        type: string;
+                        default: {};
+                    };
+                    lastTriggeredAt: {
+                        type: string;
+                    };
+                    triggerCount: {
+                        type: string;
+                        default: number;
+                        min: number;
+                    };
+                };
+            };
+        };
+        "delivery-log": {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    idempotencyKey: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    campaignSlug: {
+                        type: string;
+                        required: boolean;
+                    };
+                    channel: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                    };
+                    driver: {
+                        type: string;
+                        required: boolean;
+                    };
+                    recipientMasked: {
+                        type: string;
+                        required: boolean;
+                    };
+                    locale: {
+                        type: string;
+                        default: string;
+                        required: boolean;
+                    };
+                    status: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                    };
+                    externalMessageId: {
+                        type: string;
+                    };
+                    errorMessage: {
+                        type: string;
+                    };
+                    sentAt: {
+                        type: string;
+                        required: boolean;
+                    };
+                    secondaryDateLabel: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    controllers: {
+        broadcastController: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettings(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            updateSettings(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            listStarterTemplates(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            listEmailTemplates(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            listCampaigns(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            createCampaign(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            updateCampaign(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            createFromTemplate(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            sendCampaign(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            listAutomationRules(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            createAutomationRule(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            updateAutomationRule(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<unknown>;
+            listDeliveryLogs(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            listPublicChannels(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+            listPublicArchive(ctx: import('./controllers/broadcastController').ControllerCtx): Promise<void>;
+        };
+    };
+    routes: {
+        "content-api": {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                    auth: boolean;
+                };
+            }[];
+        };
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+    services: {
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getPluginStore(): import("@strapi/strapi").Core.PluginStore;
+            getConfigDefaults(): import('../../shared').BroadcastSettings;
+            getSettings(): Promise<import('../../shared').BroadcastSettings>;
+            getPublicSafeSettings(): Promise<import('../../shared').BroadcastSettings>;
+            updateSettings(rawPartial: Partial<import('../../shared').BroadcastSettings>): Promise<import('../../shared').BroadcastSettings>;
+        };
+        transportService: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettingsService(): {
+                getSettings(): Promise<import('../../shared').BroadcastSettings>;
+            };
+            fetchRawEmailDesignerTemplates(): Promise<import('./services/emailDesignerBridge').EmailDesignerTemplateRow[]>;
+            listEmailDesignerTemplates(): Promise<import('../../shared').EmailDesignerTemplateSummary[]>;
+            resolveEmailDesignerTemplate(templateRef: string, locale?: string): Promise<import('./services/emailDesignerBridge').EmailDesignerTemplateRow | null>;
+            hasAlreadyDelivered(idempotencyKey: string): Promise<boolean>;
+            recordDeliveryLog(entry: Omit<import('../../shared').DeliveryLogRecord, "documentId" | "sentAt">, secrets?: Array<string | undefined>): Promise<import('../../shared').DeliveryLogRecord>;
+            listDeliveryLogs(params?: {
+                campaignSlug?: string;
+                channel?: import('../../shared').BroadcastChannel;
+                limit?: number;
+            }): Promise<import('../../shared').DeliveryLogRecord[]>;
+            persistResult(campaignSlug: string, secondaryDateLabel: string | undefined, result: import('../../shared').ChannelDispatchResult, settings?: import('../../shared').BroadcastSettings): Promise<import('../../shared').ChannelDispatchResult>;
+            logOutcome(p: {
+                campaignSlug: string;
+                locale: string;
+                secondaryDateLabel?: string;
+            }, channel: import('../../shared').BroadcastChannel, driver: string, recipientMasked: string, status: import('../../shared').ChannelDispatchResult["status"], idempotencyKey: string, extra?: Partial<import('../../shared').ChannelDispatchResult>, settings?: import('../../shared').BroadcastSettings): Promise<import('../../shared').ChannelDispatchResult>;
+            simulateDryRunEmail(payload: import('./services/transportService').EmailSendPayload, effectiveTemplateRef: string, recipientMasked: string, idempotencyKey: string, settings: import('../../shared').BroadcastSettings): Promise<import('../../shared').ChannelDispatchResult>;
+            executeLiveEmailSend(payload: import('./services/transportService').EmailSendPayload, settings: import('../../shared').BroadcastSettings, effectiveTemplateRef: string, recipientMasked: string, idempotencyKey: string): Promise<import('../../shared').ChannelDispatchResult>;
+            sendEmailBroadcast(payload: import('./services/transportService').EmailSendPayload): Promise<import('../../shared').ChannelDispatchResult>;
+            sendTelegramBroadcast(payload: import('./services/transportService').TelegramSendPayload): Promise<import('../../shared').ChannelDispatchResult>;
+            sendWhatsAppBroadcast(payload: import('./services/transportService').WhatsAppSendPayload): Promise<import('../../shared').ChannelDispatchResult>;
+        };
+        campaignService: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettingsService(): {
+                getSettings(): Promise<import('../../shared').BroadcastSettings>;
+            };
+            getTransportService(): import('./services/campaignChannelDispatch').TransportServiceContract;
+            listCampaigns(params?: {
+                status?: string;
+                topic?: string;
+            }): Promise<import('../../shared').CampaignRecord[]>;
+            listPublicArchive(params?: {
+                topic?: string;
+                limit?: number;
+            }): Promise<{
+                slug: string;
+                title: string;
+                topic: string;
+                subject: string;
+                bodyText: string;
+                ctaLabel: string | undefined;
+                ctaUrl: string | undefined;
+                sentAt: string | undefined;
+                secondaryDateLabel: string | undefined;
+                translations: Record<string, import('../../shared').CampaignTranslation> | undefined;
+            }[]>;
+            getCampaignBySlug(slug: string): Promise<import('../../shared').CampaignRecord | null>;
+            findCampaignByDocIdOrSlug(documentIdOrSlug: string): Promise<import('../../shared').CampaignRecord | null>;
+            createCampaign(input: Partial<import('../../shared').CampaignRecord>): Promise<import('../../shared').CampaignRecord>;
+            updateCampaign(documentIdOrSlug: string, input: Partial<import('../../shared').CampaignRecord>): Promise<import('../../shared').CampaignRecord>;
+            createFromStarterTemplate(templateId: string): Promise<import('../../shared').CampaignRecord>;
+            seedStarterCampaigns(): Promise<number>;
+            resolveRecipientsForTopic(topic: string): Promise<import('../../shared').SubscriberRecipient[]>;
+            selectCampaignRecipients(campaign: import('../../shared').CampaignRecord, settings: import('../../shared').BroadcastSettings, options: import('./services/campaignLifecycle').RawDispatchOptions): Promise<{
+                isTestDispatch: boolean;
+                testTelegramChatId?: string;
+                recipients: import('../../shared').SubscriberRecipient[];
+            }>;
+            finalizeDispatchedCampaign(campaign: import('../../shared').CampaignRecord, secondaryDate: import('../../shared').CampaignRecord["secondaryDate"], secondaryDateLabel: string, stats: import('../../shared').CampaignStats): Promise<import('../../shared').CampaignRecord>;
+            dispatchCampaign(documentIdOrSlug: string, options?: {
+                customRecipients?: import('../../shared').SubscriberRecipient[];
+                testRecipientEmail?: string;
+                testRecipientPhone?: string;
+                testTelegramChatId?: string;
+            }): Promise<{
+                campaign: import('../../shared').CampaignRecord;
+                results: import('../../shared').ChannelDispatchResult[];
+            }>;
+        };
+        automationService: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettingsService(): {
+                getSettings(): Promise<import('../../shared').BroadcastSettings>;
+            };
+            getCampaignService(): {
+                createCampaign(input: Partial<import('../../shared').CampaignRecord>): Promise<import('../../shared').CampaignRecord>;
+                dispatchCampaign(documentIdOrSlug: string): Promise<{
+                    campaign: import('../../shared').CampaignRecord;
+                    results: import('../../shared').ChannelDispatchResult[];
+                }>;
+            };
+            listRules(): Promise<import('../../shared').AutomationRuleRecord[]>;
+            getRuleBySlug(slug: string): Promise<import('../../shared').AutomationRuleRecord | null>;
+            findRuleByDocIdOrSlug(documentIdOrSlug: string): Promise<import('../../shared').AutomationRuleRecord | null>;
+            createRule(input: Partial<import('../../shared').AutomationRuleRecord>): Promise<import('../../shared').AutomationRuleRecord>;
+            updateRule(documentIdOrSlug: string, input: Partial<import('../../shared').AutomationRuleRecord>): Promise<import('../../shared').AutomationRuleRecord>;
+            seedStarterRules(): Promise<number>;
+            executeSingleTriggerRule(rule: import('../../shared').AutomationRuleRecord, vars: Record<string, string | number | undefined>): Promise<{
+                ruleSlug: string;
+                campaignSlug: string;
+                results: import('../../shared').ChannelDispatchResult[];
+            }>;
+            handleEventTrigger(eventName: string, payload?: Record<string, unknown>): Promise<Array<{
+                ruleSlug: string;
+                campaignSlug: string;
+                results: import('../../shared').ChannelDispatchResult[];
+            }>>;
+        };
+    };
+};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+            auth: boolean;
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    "content-api": {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+                auth: boolean;
+            };
+        }[];
+    };
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/automationService.d.ts

@@ -0,0 +1,33 @@
+import { Core } from '@strapi/strapi';
+import { AutomationRuleRecord, BroadcastSettings, CampaignRecord, ChannelDispatchResult } from '../../../shared';
+declare const createAutomationService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getSettingsService(): {
+        getSettings(): Promise<BroadcastSettings>;
+    };
+    getCampaignService(): {
+        createCampaign(input: Partial<CampaignRecord>): Promise<CampaignRecord>;
+        dispatchCampaign(documentIdOrSlug: string): Promise<{
+            campaign: CampaignRecord;
+            results: ChannelDispatchResult[];
+        }>;
+    };
+    listRules(): Promise<AutomationRuleRecord[]>;
+    getRuleBySlug(slug: string): Promise<AutomationRuleRecord | null>;
+    findRuleByDocIdOrSlug(documentIdOrSlug: string): Promise<AutomationRuleRecord | null>;
+    createRule(input: Partial<AutomationRuleRecord>): Promise<AutomationRuleRecord>;
+    updateRule(documentIdOrSlug: string, input: Partial<AutomationRuleRecord>): Promise<AutomationRuleRecord>;
+    seedStarterRules(): Promise<number>;
+    executeSingleTriggerRule(rule: AutomationRuleRecord, vars: Record<string, string | number | undefined>): Promise<{
+        ruleSlug: string;
+        campaignSlug: string;
+        results: ChannelDispatchResult[];
+    }>;
+    handleEventTrigger(eventName: string, payload?: Record<string, unknown>): Promise<Array<{
+        ruleSlug: string;
+        campaignSlug: string;
+        results: ChannelDispatchResult[];
+    }>>;
+};
+export default createAutomationService;

package/dist/server/src/services/campaignChannelDispatch.d.ts

@@ -0,0 +1,20 @@
+import { BroadcastChannel, BroadcastSettings, CampaignRecord, CampaignStats, ChannelDispatchResult, SubscriberRecipient } from '../../../shared';
+import { EmailSendPayload, TelegramSendPayload, WhatsAppSendPayload } from './transportService';
+export interface TransportServiceContract {
+    sendEmailBroadcast(payload: EmailSendPayload): Promise<ChannelDispatchResult>;
+    sendTelegramBroadcast(payload: TelegramSendPayload): Promise<ChannelDispatchResult>;
+    sendWhatsAppBroadcast(payload: WhatsAppSendPayload): Promise<ChannelDispatchResult>;
+}
+export declare function buildCampaignDocumentData(candidate: Partial<CampaignRecord>, channels: BroadcastChannel[], resolvedStatus?: CampaignRecord["status"]): Record<string, unknown>;
+export declare function buildPresetCampaignPayload(preset: Partial<CampaignRecord>): Partial<CampaignRecord>;
+export declare function mapRawSubscriber(sub: Record<string, unknown>, defaultLocale: string): SubscriberRecipient;
+export declare function dispatchAllActiveChannels(params: {
+    transport: TransportServiceContract;
+    campaign: CampaignRecord;
+    settings: BroadcastSettings;
+    recipients: SubscriberRecipient[];
+    isTestDispatch: boolean;
+    testTelegramChatId?: string;
+    secondaryDateLabel: string;
+    stats: CampaignStats;
+}): Promise<ChannelDispatchResult[]>;

package/dist/server/src/services/campaignHelpers.d.ts

@@ -0,0 +1,20 @@
+import { normalizeWhatsAppTarget, BroadcastChannel, BroadcastSettings, CampaignRecord, CampaignStats, ChannelDispatchResult, SubscriberRecipient } from '../../../shared';
+import { computeIdempotencyKey } from './idempotency';
+import { EmailSendPayload, TelegramSendPayload, WhatsAppSendPayload } from './transportService';
+export { computeIdempotencyKey };
+export declare function clampLimit(val: unknown, defaultLimit: number): number;
+export declare function buildTelegramIdempotencyKey(payload: TelegramSendPayload, targetChatId: string): string;
+export declare function makeResult(channel: BroadcastChannel, driver: string, recipientMasked: string, locale: string, status: ChannelDispatchResult["status"], idempotencyKey: string, extra?: Partial<ChannelDispatchResult>): ChannelDispatchResult;
+export declare function parseTargetList(raw?: string | string[]): string[];
+export declare function resolveTelegramTargets(campaign: CampaignRecord, settings: BroadcastSettings): string[];
+export declare function resolveWhatsAppRecipients(campaign: CampaignRecord, settings: BroadcastSettings, subscribers: SubscriberRecipient[], isTestDispatch: boolean): SubscriberRecipient[];
+export declare function createEmptyStats(): CampaignStats;
+export declare function recordResultInStats(stats: CampaignStats, result: ChannelDispatchResult): void;
+export declare function resolveEffectiveEmailTemplateRef(payload: EmailSendPayload, settings: BroadcastSettings): string;
+export declare function buildEmailTemplateVariables(payload: EmailSendPayload, settings: BroadcastSettings, inlineHtml: string): Record<string, string | number | undefined>;
+export declare function buildTelegramRequestPayload(payload: TelegramSendPayload, targetChatId: string): Record<string, unknown>;
+export declare function executeTelegramHttpSend(payload: TelegramSendPayload, targetChatId: string, botToken: string): Promise<string>;
+export declare function sendViaMetaCloudApi(payload: WhatsAppSendPayload, settings: BroadcastSettings, evolutionNumber: string, fullText: string): Promise<string>;
+export declare function sendViaSelfHostedGateway(driver: string, settings: BroadcastSettings, target: ReturnType<typeof normalizeWhatsAppTarget>, fullText: string): Promise<string>;
+export declare function executeWhatsAppHttpSend(driver: string, payload: WhatsAppSendPayload, settings: BroadcastSettings, target: ReturnType<typeof normalizeWhatsAppTarget>): Promise<string>;
+export declare function hasWhatsAppCredentials(driver: string, settings: BroadcastSettings): boolean;

package/dist/server/src/services/campaignLifecycle.d.ts

@@ -0,0 +1,23 @@
+import { BroadcastSettings, CampaignRecord, CampaignStatus, SubscriberRecipient } from '../../../shared';
+export declare function resolveInitialStatus(rawStatus: CampaignStatus | undefined): CampaignStatus;
+export declare function resolveUpdatedStatus(currentStatus: CampaignStatus, requestedStatus: CampaignStatus | undefined): CampaignStatus;
+export declare function computeCampaignSecondaryDate(campaign: CampaignRecord, settings: BroadcastSettings): NonNullable<CampaignRecord["secondaryDate"]>;
+export interface RawDispatchOptions {
+    customRecipients?: unknown;
+    testRecipientEmail?: unknown;
+    testRecipientPhone?: unknown;
+    testTelegramChatId?: unknown;
+}
+export interface SanitizedDispatchOptions {
+    hasCustomRecipientsList: boolean;
+    customRecipients: SubscriberRecipient[];
+    testRecipientEmail?: string;
+    testRecipientPhone?: string;
+    testTelegramChatId?: string;
+}
+export declare function sanitizeDispatchOptions(rawOptions: RawDispatchOptions | undefined, defaultLocale: string): SanitizedDispatchOptions;
+export declare function buildSelectedRecipients(campaign: CampaignRecord, settings: BroadcastSettings, options: RawDispatchOptions, resolveTopicRecipients: (topic: string) => Promise<SubscriberRecipient[]>): Promise<{
+    isTestDispatch: boolean;
+    testTelegramChatId?: string;
+    recipients: SubscriberRecipient[];
+}>;