@superpanel-sdk/runtime 0.2.2 → 0.5.0

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

@@ -1,11 +1,16 @@
 import { z } from 'zod';
+import type { Id } from '../page/typed.js';
 export declare const CONTACT_PAGE_LIMIT_MAX = 100;
+/** A filled slot value as scripts read and write it. */
+export declare const slotFieldValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>;
+export type SlotFieldValue = z.infer<typeof slotFieldValue>;
 export declare const contactSummary: z.ZodObject<{
-    id: z.ZodString;
+    id: z.ZodCustom<Id<"contact">, Id<"contact">>;
     kind: z.ZodString;
-    externalIdentifier: z.ZodNullable<z.ZodString>;
     phone: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
 }, z.core.$strip>;
 export type ContactSummary = z.infer<typeof contactSummary>;
 export declare const contactListInput: z.ZodObject<{
@@ -17,19 +22,58 @@ export declare const contactListInput: z.ZodObject<{
 export type ContactListParams = z.infer<typeof contactListInput>;
 export declare const contactListOutput: z.ZodObject<{
     contacts: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
+        id: z.ZodCustom<Id<"contact">, Id<"contact">>;
         kind: z.ZodString;
-        externalIdentifier: z.ZodNullable<z.ZodString>;
         phone: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
         createdAt: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
     }, z.core.$strip>>;
     offset: z.ZodNumber;
     limit: z.ZodNumber;
 }, z.core.$strip>;
 export type ContactListResult = z.infer<typeof contactListOutput>;
+/** Exactly one identity: an id, a phone or an email. */
+export declare const contactFindInput: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phone: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strict>]>;
+export type ContactFindParams = z.infer<typeof contactFindInput>;
+export declare const contactFindOutput: z.ZodObject<{
+    contacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodCustom<Id<"contact">, Id<"contact">>;
+        kind: z.ZodString;
+        phone: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ContactFindResult = z.infer<typeof contactFindOutput>;
+export declare const contactCreateInput: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+}, z.core.$strict>;
+export type ContactCreateParams = z.infer<typeof contactCreateInput>;
+export declare const contactIdInput: z.ZodObject<{
+    contactId: z.ZodString;
+}, z.core.$strict>;
+export type ContactIdParams = z.infer<typeof contactIdInput>;
 /** Platform contact capability, reached from scripts as `ctx.api.contact`. */
 export type ContactApi = {
     list(input: ContactListParams): Promise<ContactListResult>;
+    /** Contacts with this id, phone or email; several people can share a phone or an email. */
+    find(input: ContactFindParams): Promise<ContactFindResult>;
+    /** A new contact with these fields filled (`kind` defaults to `person`). */
+    create(input: ContactCreateParams): Promise<ContactSummary>;
+    /**
+     * "Remove" a contact (14-sequence-instance §5.5): clear its phone, email and every other identifier
+     * field, drop their lookup rows, cancel its pending scheduled actions. The record and its history
+     * stay. An opted-out contact's addresses go to the do-not-contact list first.
+     */
+    clearContactMethods(input: ContactIdParams): Promise<ContactSummary>;
 };
 /** Stand-in surface for fake contexts and local runs; never touches the database. */
 export declare const contactMockService: ContactApi;
@@ -44,16 +88,62 @@ export declare const contactSurface: {
             }, z.core.$strip>;
             output: z.ZodObject<{
                 contacts: z.ZodArray<z.ZodObject<{
-                    id: z.ZodString;
+                    id: z.ZodCustom<Id<"contact">, Id<"contact">>;
                     kind: z.ZodString;
-                    externalIdentifier: z.ZodNullable<z.ZodString>;
                     phone: z.ZodNullable<z.ZodString>;
+                    email: z.ZodNullable<z.ZodString>;
                     createdAt: z.ZodString;
+                    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
                 }, z.core.$strip>>;
                 offset: z.ZodNumber;
                 limit: z.ZodNumber;
             }, z.core.$strip>;
         };
+        find: {
+            input: z.ZodUnion<readonly [z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                phone: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                email: z.ZodString;
+            }, z.core.$strict>]>;
+            output: z.ZodObject<{
+                contacts: z.ZodArray<z.ZodObject<{
+                    id: z.ZodCustom<Id<"contact">, Id<"contact">>;
+                    kind: z.ZodString;
+                    phone: z.ZodNullable<z.ZodString>;
+                    email: z.ZodNullable<z.ZodString>;
+                    createdAt: z.ZodString;
+                    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
+        create: {
+            input: z.ZodObject<{
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+            }, z.core.$strict>;
+            output: z.ZodObject<{
+                id: z.ZodCustom<Id<"contact">, Id<"contact">>;
+                kind: z.ZodString;
+                phone: z.ZodNullable<z.ZodString>;
+                email: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodString;
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+            }, z.core.$strip>;
+        };
+        clearContactMethods: {
+            input: z.ZodObject<{
+                contactId: z.ZodString;
+            }, z.core.$strict>;
+            output: z.ZodObject<{
+                id: z.ZodCustom<Id<"contact">, Id<"contact">>;
+                kind: z.ZodString;
+                phone: z.ZodNullable<z.ZodString>;
+                email: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodString;
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodNull]>>;
+            }, z.core.$strip>;
+        };
     };
     mock: ContactApi;
 };

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,159 @@
+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>>;
+/** Platform email-history capability, reached from scripts as `ctx.api.email`. */
+export type EmailHistoryApi = {
+    list(input: EmailListParams): Promise<EmailListResult>;
+    get(id: string): Promise<EmailRecord | null>;
+};
+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>>;
+        };
+    };
+    mock: EmailHistoryApi;
+};
+//# sourceMappingURL=email-message.d.ts.map

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

@@ -0,0 +1,59 @@
+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();
+export const emailHistoryMockService = {
+    async list(input) {
+        return { emails: [], offset: input.offset, limit: input.limit };
+    },
+    async get() {
+        return null;
+    },
+};
+export const emailHistorySurface = {
+    methods: {
+        list: { input: emailListInput, output: emailListOutput },
+        get: { input: emailGetInput, output: emailGetOutput },
+    },
+    mock: emailHistoryMockService,
+};
+//# sourceMappingURL=email-message.js.map

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

@@ -0,0 +1,97 @@
+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>;
+export type EmailService = {
+    sendEmail(input: EmailSendEmailInput): Promise<EmailSendEmailOutput>;
+    getMessage(input: EmailGetMessageInput): Promise<EmailGetMessageOutput>;
+    listMessages(input: EmailListMessagesInput): Promise<EmailListMessagesOutput>;
+    getAttachment(input: EmailGetAttachmentInput): Promise<EmailGetAttachmentOutput>;
+};
+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,91 @@
+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(),
+});
+export const emailMockService = {
+    async sendEmail() {
+        return { id: 'mock-email-id', threadId: 'mock-thread' };
+    },
+    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