@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/core/context/contact.js

@@ -1,11 +1,18 @@
 import { z } from 'zod';
+/** A contact's id, typed as one (25 §16): it goes where `db` takes a contact's id without a cast. */
+const contactId = z.custom((value) => typeof value === 'string' && value.length > 0);
 export const CONTACT_PAGE_LIMIT_MAX = 100;
+/** A filled slot value as scripts read and write it. */
+export const slotFieldValue = z.union([z.string(), z.number(), z.boolean(), z.array(z.string()), z.null()]);
 export const contactSummary = z.object({
-    id: z.string(),
+    id: contactId,
+    /** `person` or `organization` (the platform field `kind`). */
     kind: z.string(),
-    externalIdentifier: z.string().nullable(),
     phone: z.string().nullable(),
+    email: z.string().nullable(),
     createdAt: z.string(),
+    /** The contact's filled fields with a plain value, by name. */
+    fields: z.record(z.string(), slotFieldValue),
 });
 // Paging is required so a caller can never fetch an unbounded page by omission.
 export const contactListInput = z.object({
@@ -19,15 +26,54 @@ export const contactListOutput = z.object({
     offset: z.number().int(),
     limit: z.number().int(),
 });
+/** Exactly one identity: an id, a phone or an email. */
+export const contactFindInput = z.union([
+    z.strictObject({ id: z.string().min(1) }),
+    z.strictObject({ phone: z.string().min(1) }),
+    z.strictObject({ email: z.string().min(1) }),
+]);
+export const contactFindOutput = z.object({ contacts: z.array(contactSummary) });
+export const contactCreateInput = z.strictObject({
+    /** Contact fields by name, checked against the sequence's contact schema. */
+    fields: z.record(z.string(), slotFieldValue),
+});
+export const contactIdInput = z.strictObject({ contactId: z.string().min(1) });
 /** Stand-in surface for fake contexts and local runs; never touches the database. */
 export const contactMockService = {
     async list(input) {
         return { contacts: [], offset: input.offset, limit: input.limit };
     },
+    async find() {
+        return { contacts: [] };
+    },
+    async create(input) {
+        const fields = Object.fromEntries(Object.entries(input.fields).filter(([, value]) => value !== null));
+        return {
+            id: 'contact',
+            kind: typeof fields.kind === 'string' ? fields.kind : 'person',
+            phone: typeof fields.phone === 'string' ? fields.phone : null,
+            email: typeof fields.email === 'string' ? fields.email : null,
+            createdAt: new Date(0).toISOString(),
+            fields,
+        };
+    },
+    async clearContactMethods(input) {
+        return {
+            id: input.contactId,
+            kind: 'person',
+            phone: null,
+            email: null,
+            createdAt: new Date(0).toISOString(),
+            fields: {},
+        };
+    },
 };
 export const contactSurface = {
     methods: {
         list: { input: contactListInput, output: contactListOutput },
+        find: { input: contactFindInput, output: contactFindOutput },
+        create: { input: contactCreateInput, output: contactSummary },
+        clearContactMethods: { input: contactIdInput, output: contactSummary },
     },
     mock: contactMockService,
 };

package/dist/core/context/email-message.d.ts

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+export declare const EMAIL_PAGE_LIMIT_MAX = 100;
+export declare const emailDirection: z.ZodEnum<{
+    inbound: "inbound";
+    outbound: "outbound";
+}>;
+export type EmailDirection = z.infer<typeof emailDirection>;
+/** Script-facing email projection (21 §5.9). OAuth data and raw provider payloads stay private. */
+export declare const emailRecord: z.ZodObject<{
+    id: z.ZodString;
+    emailThreadId: z.ZodString;
+    threadId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodNullable<z.ZodString>;
+    contactId: z.ZodNullable<z.ZodString>;
+    runId: z.ZodNullable<z.ZodString>;
+    direction: z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>;
+    from: z.ZodArray<z.ZodString>;
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodArray<z.ZodString>;
+    subject: z.ZodNullable<z.ZodString>;
+    body: z.ZodNullable<z.ZodString>;
+    processing: z.ZodNullable<z.ZodString>;
+    delivery: z.ZodNullable<z.ZodString>;
+    occurredAt: z.ZodString;
+}, z.core.$strip>;
+export type EmailRecord = z.infer<typeof emailRecord>;
+export declare const emailListInput: z.ZodObject<{
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+    instanceId: z.ZodOptional<z.ZodString>;
+    contactId: z.ZodOptional<z.ZodString>;
+    emailThreadId: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>>;
+}, z.core.$strip>;
+export type EmailListParams = z.infer<typeof emailListInput>;
+export declare const emailListOutput: z.ZodObject<{
+    emails: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        emailThreadId: z.ZodString;
+        threadId: z.ZodNullable<z.ZodString>;
+        instanceId: z.ZodNullable<z.ZodString>;
+        contactId: z.ZodNullable<z.ZodString>;
+        runId: z.ZodNullable<z.ZodString>;
+        direction: z.ZodEnum<{
+            inbound: "inbound";
+            outbound: "outbound";
+        }>;
+        from: z.ZodArray<z.ZodString>;
+        to: z.ZodArray<z.ZodString>;
+        cc: z.ZodArray<z.ZodString>;
+        subject: z.ZodNullable<z.ZodString>;
+        body: z.ZodNullable<z.ZodString>;
+        processing: z.ZodNullable<z.ZodString>;
+        delivery: z.ZodNullable<z.ZodString>;
+        occurredAt: z.ZodString;
+    }, z.core.$strip>>;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type EmailListResult = z.infer<typeof emailListOutput>;
+export declare const emailGetInput: z.ZodString;
+export declare const emailGetOutput: z.ZodNullable<z.ZodObject<{
+    id: z.ZodString;
+    emailThreadId: z.ZodString;
+    threadId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodNullable<z.ZodString>;
+    contactId: z.ZodNullable<z.ZodString>;
+    runId: z.ZodNullable<z.ZodString>;
+    direction: z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>;
+    from: z.ZodArray<z.ZodString>;
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodArray<z.ZodString>;
+    subject: z.ZodNullable<z.ZodString>;
+    body: z.ZodNullable<z.ZodString>;
+    processing: z.ZodNullable<z.ZodString>;
+    delivery: z.ZodNullable<z.ZodString>;
+    occurredAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * An email sent now (64 §15), from any entry, as a text is (`ctx.api.sms.send`): one recipient, no cc or bcc.
+ * `to` is a contact's row id, or `{ address }` for someone who is not one (an on-call lawyer, opposing
+ * counsel). An address that is a contact's of this environment is sent as to that contact: their opt-outs
+ * are checked. `from` names the mailbox (its name in the environment); absent, a contact's own mailbox (one
+ * picked at random is remembered on them), else any active one. It goes back in the newest thread with
+ * them on that mailbox, else starts one; stored with the run, then sent. The case it is about, and who
+ * hears `email.sent`: as for a text. Pause and contact hours are not checked.
+ */
+export declare const emailSendInput: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        address: z.ZodString;
+    }, z.core.$strict>]>;
+    body: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    instanceId: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type EmailSendParams = z.infer<typeof emailSendInput>;
+/** The thread the email went on (`email.sent` on the case's timeline). */
+export declare const emailSendOutput: z.ZodObject<{
+    exchangeId: z.ZodString;
+}, z.core.$strip>;
+export type EmailSendResult = z.infer<typeof emailSendOutput>;
+/** Platform email capability, reached from scripts as `ctx.api.email`: the history, and sending one now. */
+export type EmailHistoryApi = {
+    list(input: EmailListParams): Promise<EmailListResult>;
+    get(id: string): Promise<EmailRecord | null>;
+    send(input: EmailSendParams): Promise<EmailSendResult>;
+};
+export declare const emailHistoryMockService: EmailHistoryApi;
+export declare const emailHistorySurface: {
+    methods: {
+        list: {
+            input: z.ZodObject<{
+                offset: z.ZodNumber;
+                limit: z.ZodNumber;
+                instanceId: z.ZodOptional<z.ZodString>;
+                contactId: z.ZodOptional<z.ZodString>;
+                emailThreadId: z.ZodOptional<z.ZodString>;
+                direction: z.ZodOptional<z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>>;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                emails: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    emailThreadId: z.ZodString;
+                    threadId: z.ZodNullable<z.ZodString>;
+                    instanceId: z.ZodNullable<z.ZodString>;
+                    contactId: z.ZodNullable<z.ZodString>;
+                    runId: z.ZodNullable<z.ZodString>;
+                    direction: z.ZodEnum<{
+                        inbound: "inbound";
+                        outbound: "outbound";
+                    }>;
+                    from: z.ZodArray<z.ZodString>;
+                    to: z.ZodArray<z.ZodString>;
+                    cc: z.ZodArray<z.ZodString>;
+                    subject: z.ZodNullable<z.ZodString>;
+                    body: z.ZodNullable<z.ZodString>;
+                    processing: z.ZodNullable<z.ZodString>;
+                    delivery: z.ZodNullable<z.ZodString>;
+                    occurredAt: z.ZodString;
+                }, z.core.$strip>>;
+                offset: z.ZodNumber;
+                limit: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+        get: {
+            input: z.ZodString;
+            output: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                emailThreadId: z.ZodString;
+                threadId: z.ZodNullable<z.ZodString>;
+                instanceId: z.ZodNullable<z.ZodString>;
+                contactId: z.ZodNullable<z.ZodString>;
+                runId: z.ZodNullable<z.ZodString>;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodArray<z.ZodString>;
+                to: z.ZodArray<z.ZodString>;
+                cc: z.ZodArray<z.ZodString>;
+                subject: z.ZodNullable<z.ZodString>;
+                body: z.ZodNullable<z.ZodString>;
+                processing: z.ZodNullable<z.ZodString>;
+                delivery: z.ZodNullable<z.ZodString>;
+                occurredAt: z.ZodString;
+            }, z.core.$strip>>;
+        };
+        send: {
+            input: z.ZodObject<{
+                to: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    address: z.ZodString;
+                }, z.core.$strict>]>;
+                body: z.ZodString;
+                subject: z.ZodOptional<z.ZodString>;
+                instanceId: z.ZodOptional<z.ZodString>;
+                from: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            output: z.ZodObject<{
+                exchangeId: z.ZodString;
+            }, z.core.$strip>;
+        };
+    };
+    mock: EmailHistoryApi;
+};
+//# sourceMappingURL=email-message.d.ts.map

package/dist/core/context/email-message.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export const EMAIL_PAGE_LIMIT_MAX = 100;
+export const emailDirection = z.enum(['inbound', 'outbound']);
+/** Script-facing email projection (21 §5.9). OAuth data and raw provider payloads stay private. */
+export const emailRecord = z.object({
+    id: z.string(),
+    /** Our thread (21 §5.9): `ExchangeRef` `{ channel: 'email', emailThreadId }`. */
+    emailThreadId: z.string(),
+    /** The provider's thread id (null for a thread we started, until its first email went). */
+    threadId: z.string().nullable(),
+    instanceId: z.string().nullable(),
+    /** Inbound: who sent it, as recognized on the thread. */
+    contactId: z.string().nullable(),
+    /** Inbound: the run that handled it; outbound: the run that sent it (null: the platform did). */
+    runId: z.string().nullable(),
+    direction: emailDirection,
+    from: z.array(z.string()),
+    to: z.array(z.string()),
+    cc: z.array(z.string()),
+    subject: z.string().nullable(),
+    /** The new text, without the quoted history. */
+    body: z.string().nullable(),
+    /** Inbound: pending | claimed | processed | skipped | declined | failed. */
+    processing: z.string().nullable(),
+    /** Outbound: pending | submitting | sent | failed. */
+    delivery: z.string().nullable(),
+    occurredAt: z.string(),
+});
+export const emailListInput = z.object({
+    offset: z.number().int().min(0),
+    limit: z.number().int().min(1).max(EMAIL_PAGE_LIMIT_MAX),
+    instanceId: z.string().optional(),
+    contactId: z.string().optional(),
+    emailThreadId: z.string().optional(),
+    direction: emailDirection.optional(),
+});
+export const emailListOutput = z.object({
+    emails: z.array(emailRecord),
+    offset: z.number().int(),
+    limit: z.number().int(),
+});
+export const emailGetInput = z.string().min(1);
+export const emailGetOutput = emailRecord.nullable();
+/**
+ * An email sent now (64 §15), from any entry, as a text is (`ctx.api.sms.send`): one recipient, no cc or bcc.
+ * `to` is a contact's row id, or `{ address }` for someone who is not one (an on-call lawyer, opposing
+ * counsel). An address that is a contact's of this environment is sent as to that contact: their opt-outs
+ * are checked. `from` names the mailbox (its name in the environment); absent, a contact's own mailbox (one
+ * picked at random is remembered on them), else any active one. It goes back in the newest thread with
+ * them on that mailbox, else starts one; stored with the run, then sent. The case it is about, and who
+ * hears `email.sent`: as for a text. Pause and contact hours are not checked.
+ */
+export const emailSendInput = z
+    .object({
+    to: z.union([z.string().min(1), z.object({ address: z.string().min(1) }).strict()]),
+    body: z.string().min(1),
+    /** Absent: a reply to the thread's subject, or a plain one for a new thread. */
+    subject: z.string().optional(),
+    /** The case the email is about, any of this environment's; absent: the run's own case, if any. */
+    instanceId: z.string().min(1).optional(),
+    /** The mailbox to send from, by its name in the environment. */
+    from: z.string().min(1).optional(),
+})
+    .strict();
+/** The thread the email went on (`email.sent` on the case's timeline). */
+export const emailSendOutput = z.object({ exchangeId: z.string() });
+export const emailHistoryMockService = {
+    async list(input) {
+        return { emails: [], offset: input.offset, limit: input.limit };
+    },
+    async get() {
+        return null;
+    },
+    async send() {
+        return { exchangeId: 'mock-email' };
+    },
+};
+export const emailHistorySurface = {
+    methods: {
+        list: { input: emailListInput, output: emailListOutput },
+        get: { input: emailGetInput, output: emailGetOutput },
+        send: { input: emailSendInput, output: emailSendOutput },
+    },
+    mock: emailHistoryMockService,
+};
+//# sourceMappingURL=email-message.js.map

package/dist/core/context/email.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import type { IntegrationAccountFields } from './account-fields.js';
+/** `hotmail` covers every Microsoft account (Outlook.com / Hotmail / M365). */
+export declare const emailProvider: z.ZodEnum<{
+    gmail: "gmail";
+    hotmail: "hotmail";
+}>;
+export type EmailProvider = z.infer<typeof emailProvider>;
+export declare const emailSendEmailInput: z.ZodObject<{
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subject: z.ZodString;
+    body: z.ZodString;
+    threadId: z.ZodOptional<z.ZodString>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodString>;
+    replyToId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EmailSendEmailInput = z.infer<typeof emailSendEmailInput>;
+export declare const emailSendEmailOutput: z.ZodObject<{
+    id: z.ZodString;
+    threadId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EmailSendEmailOutput = z.infer<typeof emailSendEmailOutput>;
+export declare const emailGetMessageInput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type EmailGetMessageInput = z.infer<typeof emailGetMessageInput>;
+export declare const emailAttachment: z.ZodObject<{
+    filename: z.ZodString;
+    contentType: z.ZodString;
+    attachmentId: z.ZodString;
+    isInline: z.ZodBoolean;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type EmailAttachment = z.infer<typeof emailAttachment>;
+export declare const emailGetMessageOutput: z.ZodObject<{
+    id: z.ZodString;
+    threadId: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodArray<z.ZodString>;
+    bcc: z.ZodArray<z.ZodString>;
+    subject: z.ZodString;
+    text: z.ZodString;
+    html: z.ZodString;
+    date: z.ZodString;
+    messageId: z.ZodString;
+    labelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attachments: z.ZodArray<z.ZodObject<{
+        filename: z.ZodString;
+        contentType: z.ZodString;
+        attachmentId: z.ZodString;
+        isInline: z.ZodBoolean;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    autoHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type EmailGetMessageOutput = z.infer<typeof emailGetMessageOutput>;
+export declare const emailListMessagesInput: z.ZodObject<{
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EmailListMessagesInput = z.infer<typeof emailListMessagesInput>;
+export declare const emailListMessagesOutput: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EmailListMessagesOutput = z.infer<typeof emailListMessagesOutput>;
+export declare const emailGetAttachmentInput: z.ZodObject<{
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
+}, z.core.$strip>;
+export type EmailGetAttachmentInput = z.infer<typeof emailGetAttachmentInput>;
+export declare const emailGetAttachmentOutput: z.ZodObject<{
+    filename: z.ZodString;
+    contentType: z.ZodString;
+    data: z.ZodString;
+}, z.core.$strip>;
+export type EmailGetAttachmentOutput = z.infer<typeof emailGetAttachmentOutput>;
+/**
+ * A mailbox as company code reaches it (`ctx.api.integration.emails[]`): reading its messages and their
+ * attachments. Sending is `ctx.api.email.send` (64 §15): opt-outs checked, stored, threaded, on the case.
+ */
+export type EmailService = {
+    getMessage(input: EmailGetMessageInput): Promise<EmailGetMessageOutput>;
+    listMessages(input: EmailListMessagesInput): Promise<EmailListMessagesOutput>;
+    getAttachment(input: EmailGetAttachmentInput): Promise<EmailGetAttachmentOutput>;
+};
+/**
+ * The mail provider as the platform drives it: the reads, and handing an email to Gmail / Outlook as is
+ * (no opt-out check, no record). The platform's own; company code never reaches `sendEmail`.
+ */
+export type EmailProviderService = EmailService & {
+    sendEmail(input: EmailSendEmailInput): Promise<EmailSendEmailOutput>;
+};
+/** The provider methods only the platform calls: left out of the company's script surface. */
+export declare const EMAIL_PLATFORM_ONLY_METHODS: readonly ["sendEmail"];
+export declare const emailMockService: EmailService;
+export type EmailApi = IntegrationAccountFields & EmailService & {
+    readonly address: string;
+    readonly provider: EmailProvider;
+};
+//# sourceMappingURL=email.d.ts.map

package/dist/core/context/email.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+/** `hotmail` covers every Microsoft account (Outlook.com / Hotmail / M365). */
+export const emailProvider = z.enum(['gmail', 'hotmail']);
+export const emailSendEmailInput = z.object({
+    to: z.array(z.string()).min(1),
+    cc: z.array(z.string()).optional(),
+    bcc: z.array(z.string()).optional(),
+    subject: z.string(),
+    body: z.string(),
+    threadId: z.string().optional(),
+    inReplyTo: z.string().optional(),
+    references: z.string().optional(),
+    replyToId: z.string().optional(),
+});
+export const emailSendEmailOutput = z.object({
+    id: z.string(),
+    threadId: z.string().optional(),
+});
+export const emailGetMessageInput = z.object({
+    id: z.string(),
+});
+export const emailAttachment = z.object({
+    filename: z.string(),
+    contentType: z.string(),
+    attachmentId: z.string(),
+    isInline: z.boolean(),
+    size: z.number().optional(),
+});
+export const emailGetMessageOutput = z.object({
+    id: z.string(),
+    threadId: z.string(),
+    from: z.string(),
+    to: z.array(z.string()),
+    cc: z.array(z.string()),
+    bcc: z.array(z.string()),
+    subject: z.string(),
+    text: z.string(),
+    html: z.string(),
+    date: z.string(),
+    messageId: z.string(),
+    labelIds: z.array(z.string()).optional(),
+    attachments: z.array(emailAttachment),
+    /** The headers that mark automatic mail (Auto-Submitted, Precedence, List-Id, X-Autoreply…), lower-cased names. */
+    autoHeaders: z.record(z.string(), z.string()).optional(),
+});
+export const emailListMessagesInput = z.object({
+    maxResults: z.number().optional(),
+    query: z.string().optional(),
+    pageToken: z.string().optional(),
+});
+export const emailListMessagesOutput = z.object({
+    messages: z.array(z.object({ id: z.string(), threadId: z.string() })),
+    nextPageToken: z.string().optional(),
+});
+export const emailGetAttachmentInput = z.object({
+    messageId: z.string(),
+    attachmentId: z.string(),
+});
+export const emailGetAttachmentOutput = z.object({
+    filename: z.string(),
+    contentType: z.string(),
+    data: z.string(),
+});
+/** The provider methods only the platform calls: left out of the company's script surface. */
+export const EMAIL_PLATFORM_ONLY_METHODS = ['sendEmail'];
+export const emailMockService = {
+    async getMessage() {
+        return {
+            id: 'mock-email-id',
+            threadId: 'mock-thread',
+            from: 'sender@example.com',
+            to: ['intake@example.com'],
+            cc: [],
+            bcc: [],
+            subject: '',
+            text: '',
+            html: '',
+            date: '1970-01-01T00:00:00.000Z',
+            messageId: '',
+            attachments: [],
+        };
+    },
+    async listMessages() {
+        return { messages: [] };
+    },
+    async getAttachment() {
+        return { filename: 'file', contentType: 'application/octet-stream', data: '' };
+    },
+};
+//# sourceMappingURL=email.js.map