@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/gmail/tools/list-threads.d.ts

@@ -1,8 +1,8 @@
 export declare const listThreads: import("ai").Tool<{
     maxResults: number;
     gmailToken?: string | undefined;
-    q?: string | undefined;
     pageToken?: string | undefined;
+    q?: string | undefined;
 }, {
     error: string;
     details: any;

package/dist/toolkits/gmail/tools/mailbox.d.ts

@@ -0,0 +1,46 @@
+export declare const listFilters: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const listHistory: import("ai").Tool<{
+    userId: string;
+    startHistoryId: string;
+    gmailToken?: string | undefined;
+    labelId?: string | undefined;
+    historyTypes?: ("messageAdded" | "messageDeleted" | "labelAdded" | "labelRemoved")[] | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, any>;
+export declare const listCseIdentities: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const listCseKeypairs: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const importMessage: import("ai").Tool<{
+    userId: string;
+    raw: string;
+    gmailToken?: string | undefined;
+    deleted?: boolean | undefined;
+    neverMarkSpam?: boolean | undefined;
+    internalDateSource?: "receivedTime" | "dateHeader" | undefined;
+    processForCalendar?: boolean | undefined;
+}, any>;
+export declare const insertMessage: import("ai").Tool<{
+    userId: string;
+    raw: string;
+    gmailToken?: string | undefined;
+    deleted?: boolean | undefined;
+    internalDateSource?: "receivedTime" | "dateHeader" | undefined;
+}, any>;
+export declare const stopWatch: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=mailbox.d.ts.map

package/dist/toolkits/gmail/tools/mailbox.js

@@ -0,0 +1,142 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const userField = z.string().optional().default('me').describe("User's email address or 'me' for the authenticated user");
+async function gmailFetch(token, path, init, label = 'Gmail request') {
+    try {
+        const response = await fetch(`https://gmail.googleapis.com/gmail/v1${path}`, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...(init?.headers || {}),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        if (response.status === 204)
+            return { success: true };
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export const listFilters = tool({
+    description: 'List all Gmail filters. Audit for malicious rules or check for duplicates before creating new ones.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/filters`, undefined, 'list filters'),
+});
+export const listHistory = tool({
+    description: 'List mailbox changes since a history ID for incremental sync. Persist the newest historyId as checkpoint; empty history is valid (no changes).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        startHistoryId: z.string().describe('Numeric history ID to sync from (get via get-profile)'),
+        labelId: z.string().optional().describe('Restrict to changes on this label, e.g. INBOX'),
+        historyTypes: z.array(z.enum(['messageAdded', 'messageDeleted', 'labelAdded', 'labelRemoved'])).optional(),
+        maxResults: z.number().int().min(1).max(500).optional().describe('Records per page (default 100, max 500)'),
+        pageToken: z.string().optional().describe('Next page token; loop until absent'),
+    }),
+    execute: async ({ gmailToken, userId, startHistoryId, labelId, historyTypes, maxResults, pageToken }) => {
+        const params = new URLSearchParams({ startHistoryId });
+        if (labelId)
+            params.append('labelId', labelId);
+        if (maxResults)
+            params.append('maxResults', String(maxResults));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        for (const t of historyTypes || [])
+            params.append('historyTypes', t);
+        return gmailFetch(gmailToken, `/users/${userId}/history?${params.toString()}`, undefined, 'list history');
+    },
+});
+export const listCseIdentities = tool({
+    description: 'List client-side encryption sending identities with key-pair associations (Workspace CSE only).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        pageSize: z.number().int().min(1).optional().describe('Identities per page (default 20)'),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ gmailToken, userId, pageSize, pageToken }) => {
+        const params = new URLSearchParams();
+        if (pageSize)
+            params.append('pageSize', String(pageSize));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        return gmailFetch(gmailToken, `/users/${userId}/settings/cse/identities${qs}`, undefined, 'list CSE identities');
+    },
+});
+export const listCseKeypairs = tool({
+    description: 'List client-side encryption key pairs (public certs, enablement state). Paginate with page tokens.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        pageSize: z.number().int().min(1).optional().describe('Key pairs per page (default 20)'),
+        pageToken: z.string().optional().describe('Omit for the first page'),
+    }),
+    execute: async ({ gmailToken, userId, pageSize, pageToken }) => {
+        const params = new URLSearchParams();
+        if (pageSize)
+            params.append('pageSize', String(pageSize));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        return gmailFetch(gmailToken, `/users/${userId}/settings/cse/keypairs${qs}`, undefined, 'list CSE key pairs');
+    },
+});
+export const importMessage = tool({
+    description: 'Import an RFC 2822 base64url message with delivery scanning/classification (no SMTP, no SPF checks).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        raw: z.string().describe('Full RFC 2822 message, base64url-encoded'),
+        deleted: z.boolean().optional().describe('Vault-only delete (Workspace only)'),
+        neverMarkSpam: z.boolean().optional().describe('Bypass spam classifier'),
+        internalDateSource: z.enum(['receivedTime', 'dateHeader']).optional(),
+        processForCalendar: z.boolean().optional().describe('Extract calendar invites to Google Calendar'),
+    }),
+    execute: async ({ gmailToken, userId, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/messages/import`, { method: 'POST', body: JSON.stringify(payload) }, 'import message');
+    },
+});
+export const insertMessage = tool({
+    description: 'Insert an RFC 2822 base64url message directly (IMAP APPEND equivalent), bypassing most scanning. Does not send.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        raw: z.string().describe('Full RFC 2822 message, base64url-encoded'),
+        deleted: z.boolean().optional().describe('Vault-only delete (Workspace only)'),
+        internalDateSource: z.enum(['receivedTime', 'dateHeader']).optional(),
+    }),
+    execute: async ({ gmailToken, userId, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/messages`, { method: 'POST', body: JSON.stringify(payload) }, 'insert message');
+    },
+});
+export const stopWatch = tool({
+    description: 'Stop Gmail push notifications for the mailbox previously configured via watch.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/stop`, { method: 'POST' }, 'stop watch'),
+});
+//# sourceMappingURL=mailbox.js.map

package/dist/toolkits/gmail/tools/messages-extra.d.ts

@@ -0,0 +1,34 @@
+export declare const fetchEmails: import("ai").Tool<{
+    userId: string;
+    query?: string | undefined;
+    gmailToken?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    labelIds?: string[] | undefined;
+    includeSpamTrash?: boolean | undefined;
+    idsOnly?: boolean | undefined;
+    includePayload?: boolean | undefined;
+}, any>;
+export declare const getProfile: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const whoAmI: import("ai").Tool<{
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateDraft: import("ai").Tool<{
+    userId: string;
+    draftId: string;
+    body?: string | undefined;
+    gmailToken?: string | undefined;
+    threadId?: string | undefined;
+    recipientEmail?: string | undefined;
+    extraRecipients?: string[] | undefined;
+    cc?: string[] | undefined;
+    bcc?: string[] | undefined;
+    subject?: string | undefined;
+    isHtml?: boolean | undefined;
+    attachmentUrl?: string | undefined;
+    attachmentName?: string | undefined;
+}, any>;
+//# sourceMappingURL=messages-extra.d.ts.map

package/dist/toolkits/gmail/tools/messages-extra.js

@@ -0,0 +1,176 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeBase64Url, encodeMultipartMessage, extractMessageDetails } from './utils.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const userField = z.string().optional().default('me').describe("User's email address or 'me' for the authenticated user");
+async function gmailFetch(token, path, init, label = 'Gmail request') {
+    try {
+        const response = await fetch(`https://gmail.googleapis.com/gmail/v1${path}`, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...(init?.headers || {}),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        if (response.status === 204)
+            return { success: true };
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export const fetchEmails = tool({
+    description: 'Search/list emails with optional hydration: ids_only (fastest), metadata, or full payload. Sort by internalDate client-side; loop page tokens for full coverage.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        query: z.string().optional().describe("Search query, e.g. 'from:x is:unread' (use 'is:' for states, 'label:' only for custom labels)"),
+        labelIds: z.array(z.string()).optional().describe('AND filter by label IDs (custom labels need Label_XXX IDs from list-labels)'),
+        maxResults: z.number().int().min(1).max(500).optional().describe('Messages per page (default 10)'),
+        pageToken: z.string().optional().describe('Next page token; loop until absent'),
+        includeSpamTrash: z.boolean().optional().describe('Include SPAM and TRASH'),
+        idsOnly: z.boolean().optional().describe('Return only IDs/thread IDs (fastest)'),
+        includePayload: z.boolean().optional().describe('Hydrate full payload per message (default true unless idsOnly)'),
+    }),
+    execute: async ({ gmailToken, userId, query, labelIds, maxResults, pageToken, includeSpamTrash, idsOnly, includePayload }) => {
+        const params = new URLSearchParams();
+        if (query)
+            params.append('q', query);
+        if (maxResults)
+            params.append('maxResults', String(maxResults));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        if (includeSpamTrash)
+            params.append('includeSpamTrash', 'true');
+        for (const id of labelIds || [])
+            params.append('labelIds', id);
+        const list = await gmailFetch(gmailToken, `/users/${userId}/messages?${params.toString()}`, undefined, 'list emails');
+        if (list?.error || idsOnly)
+            return list;
+        const hydrate = includePayload !== false;
+        const messages = await Promise.all((list?.messages || []).map(async (m) => {
+            const full = await gmailFetch(gmailToken, `/users/${userId}/messages/${m.id}?format=${hydrate ? 'full' : 'metadata'}`, undefined, 'hydrate email');
+            if (full?.error)
+                return { messageId: m.id, threadId: m.threadId, error: full.error };
+            return hydrate ? extractMessageDetails(full) : full;
+        }));
+        return { ...list, messages };
+    },
+});
+export const getProfile = tool({
+    description: 'Get mailbox profile (primary email, message/thread totals, historyId). historyId seeds incremental sync via list-history.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/profile`, undefined, 'get profile'),
+});
+export const whoAmI = tool({
+    description: 'Return the connected account identity (sub, name, email, hosted domain) via userinfo + Gmail profile.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+    }),
+    execute: async ({ gmailToken }) => {
+        try {
+            const [userinfo, profile] = await Promise.all([
+                fetch('https://www.googleapis.com/oauth2/v3/userinfo', {
+                    headers: { Authorization: `Bearer ${gmailToken}` },
+                }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
+                gmailFetch(gmailToken, '/users/me/profile', undefined, 'get profile'),
+            ]);
+            if (!userinfo && profile?.error)
+                return profile;
+            return {
+                sub: userinfo?.sub ?? null,
+                name: userinfo?.name ?? null,
+                email: userinfo?.email ?? profile?.emailAddress ?? null,
+                hosted_domain: userinfo?.hd ?? null,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting identity',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+function buildMime(input) {
+    const lines = [
+        `To: ${input.to.join(', ')}`,
+        input.cc?.length ? `Cc: ${input.cc.join(', ')}` : null,
+        input.bcc?.length ? `Bcc: ${input.bcc.join(', ')}` : null,
+        `Subject: ${input.subject ?? ''}`,
+        'MIME-Version: 1.0',
+        `Content-Type: ${input.isHtml ? 'text/html' : 'text/plain'}; charset="UTF-8"`,
+        'Content-Transfer-Encoding: 8bit',
+    ].filter(Boolean);
+    let body = input.body ?? '';
+    if (!input.isHtml)
+        body = body.replace(/\n/g, '<br/>');
+    return encodeBase64Url(`${lines.join('\n')}\n\n${body}`);
+}
+async function fetchPublicUrlBytes(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            return null;
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return {
+            data: buffer.toString('base64'),
+            mimeType: response.headers.get('content-type') || 'application/octet-stream',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export const updateDraft = tool({
+    description: 'Replace a draft entirely by ID (full replace, not patch). Provide complete content; attachments via public URL only.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        draftId: z.string().describe('Draft ID from list-drafts or create-draft'),
+        recipientEmail: z.string().optional().describe('Primary To recipient'),
+        extraRecipients: z.array(z.string()).optional().describe('Additional To recipients'),
+        cc: z.array(z.string()).optional(),
+        bcc: z.array(z.string()).optional(),
+        subject: z.string().optional(),
+        body: z.string().optional().describe('Plain text or HTML (set isHtml for HTML)'),
+        isHtml: z.boolean().optional(),
+        threadId: z.string().optional().describe('Keep the draft in this thread'),
+        attachmentUrl: z.string().optional().describe('Public file URL to attach (Drive links for >25 MB total)'),
+        attachmentName: z.string().optional().describe('Filename for the attached URL'),
+    }),
+    execute: async ({ gmailToken, userId, draftId, recipientEmail, extraRecipients, cc, bcc, subject, body, isHtml, threadId, attachmentUrl, attachmentName }) => {
+        const to = [recipientEmail, ...(extraRecipients || [])].filter(Boolean);
+        let raw = buildMime({ to, cc, bcc, subject, body, isHtml, threadId });
+        if (attachmentUrl) {
+            const fetched = await fetchPublicUrlBytes(attachmentUrl);
+            if (!fetched)
+                return { error: 'Failed to update draft', details: 'Attachment URL could not be fetched (must be public)' };
+            raw = encodeMultipartMessage({
+                to: to.join(', '),
+                subject: subject ?? '',
+                body: body ?? '',
+                cc: cc?.join(', '),
+                bcc: bcc?.join(', '),
+                attachments: [{ filename: attachmentName || 'attachment', mimeType: fetched.mimeType, data: fetched.data }],
+            });
+        }
+        const payload = { message: { raw } };
+        if (threadId)
+            payload.message.threadId = threadId;
+        return gmailFetch(gmailToken, `/users/${userId}/drafts/${draftId}`, { method: 'PUT', body: JSON.stringify(payload) }, 'update draft');
+    },
+});
+//# sourceMappingURL=messages-extra.js.map

package/dist/toolkits/gmail/tools/people-extra.d.ts

@@ -0,0 +1,18 @@
+export declare const getPeople: import("ai").Tool<{
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    resourceName?: string | undefined;
+    personFields?: string | undefined;
+    otherContacts?: boolean | undefined;
+    syncToken?: string | undefined;
+    sources?: ("READ_SOURCE_TYPE_CONTACT" | "READ_SOURCE_TYPE_PROFILE")[] | undefined;
+}, any>;
+export declare const searchPeople: import("ai").Tool<{
+    query: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    personFields?: string | undefined;
+}, any>;
+//# sourceMappingURL=people-extra.d.ts.map

package/dist/toolkits/gmail/tools/people-extra.js

@@ -0,0 +1,67 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+async function peopleFetch(token, path, params, label) {
+    try {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(params))
+            if (v)
+                qs.append(k, v);
+        const url = `https://people.googleapis.com/v1/${path}${qs.toString() ? `?${qs.toString()}` : ''}`;
+        const response = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+const personFieldsField = z.string().optional().describe("Comma-separated mask, e.g. 'names,emailAddresses' (other-contacts mode allows only emailAddresses, names, phoneNumbers, metadata)");
+export const getPeople = tool({
+    description: "Get one person by resource name, or list 'Other Contacts' with pagination/sync tokens. Other-contacts mode restricts person_fields.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        resourceName: z.string().optional().describe("Person resource, e.g. 'people/me' or 'people/c123...' (ignored when otherContacts is true)"),
+        personFields: personFieldsField,
+        otherContacts: z.boolean().optional().describe("True: list Other Contacts (enables pageSize/pageToken/syncToken, ignores resourceName)"),
+        pageSize: z.number().int().min(1).max(1000).optional().describe('Other-contacts page size (default 10)'),
+        pageToken: z.string().optional().describe('Other-contacts next page token'),
+        syncToken: z.string().optional().describe('Other-contacts incremental sync token (empty = full sync)'),
+        sources: z.array(z.enum(['READ_SOURCE_TYPE_CONTACT', 'READ_SOURCE_TYPE_PROFILE'])).optional().describe('Other-contacts sources (PROFILE needs CONTACT too)'),
+    }),
+    execute: async ({ gmailToken, resourceName, personFields, otherContacts, pageSize, pageToken, syncToken, sources }) => {
+        if (otherContacts) {
+            return peopleFetch(gmailToken, 'otherContacts', {
+                readMask: personFields,
+                pageSize: pageSize ? String(pageSize) : undefined,
+                pageToken,
+                syncToken,
+                ...(sources ? { sources: sources.join(',') } : {}),
+            }, 'list other contacts');
+        }
+        return peopleFetch(gmailToken, resourceName || 'people/me', { personFields }, 'get person');
+    },
+});
+export const searchPeople = tool({
+    description: "Search saved contacts (+ Other Contacts optionally) by name/email/phone/org. Never auto-pick from ambiguous results; dedupe by email across pages.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        query: z.string().describe('Query matching names, nicknames, emails, phones, organizations'),
+        personFields: z.string().optional().describe("Mask, e.g. 'names,emailAddresses'. Results touching 'Other Contacts' only support emailAddresses, metadata, names, phoneNumbers — avoid organizations/birthdays or they may be silently omitted."),
+        pageSize: z.number().int().min(0).max(30).optional().describe('Results per page (default 10, API caps at 30)'),
+        pageToken: z.string().optional().describe('next_page_token from previous page'),
+    }),
+    execute: async ({ gmailToken, query, personFields, pageSize, pageToken }) => peopleFetch(gmailToken, 'people:searchContacts', {
+        query,
+        readMask: personFields,
+        pageSize: pageSize ? String(pageSize) : undefined,
+        pageToken,
+    }, 'search people'),
+});
+//# sourceMappingURL=people-extra.js.map

package/dist/toolkits/gmail/tools/settings.d.ts

@@ -0,0 +1,100 @@
+export declare const getLanguageSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateLanguageSettings: import("ai").Tool<{
+    userId: string;
+    displayLanguage: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const getVacationSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateVacationSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    enableAutoReply?: boolean | undefined;
+    responseSubject?: string | undefined;
+    responseBodyPlainText?: string | undefined;
+    responseBodyHtml?: string | undefined;
+    restrictToContacts?: boolean | undefined;
+    restrictToDomain?: boolean | undefined;
+    startTime?: string | undefined;
+    endTime?: string | undefined;
+}, any>;
+export declare const settingsGetImap: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateImapSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    enabled?: boolean | undefined;
+    autoExpunge?: boolean | undefined;
+    expungeBehavior?: "expungeBehaviorUnspecified" | "archive" | "trash" | "deleteForever" | undefined;
+    maxFolderSize?: number | undefined;
+}, any>;
+export declare const settingsGetPop: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updatePopSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    accessWindow?: "accessWindowUnspecified" | "disabled" | "fromNowOn" | "allMail" | undefined;
+    disposition?: "archive" | "trash" | "dispositionUnspecified" | "leaveInInbox" | "markRead" | undefined;
+}, any>;
+export declare const listSendAs: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const settingsSendAsGet: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const patchSendAs: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+    displayName?: string | undefined;
+    replyToAddress?: string | undefined;
+    signature?: string | undefined;
+    isDefault?: boolean | undefined;
+    treatAsAlias?: boolean | undefined;
+    smtpMsa?: {
+        host: string;
+        port: number;
+        securityMode: "none" | "securityModeUnspecified" | "ssl" | "starttls";
+        username?: string | undefined;
+        password?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const updateSendAs: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+    displayName?: string | undefined;
+    replyToAddress?: string | undefined;
+    signature?: string | undefined;
+    isDefault?: boolean | undefined;
+    treatAsAlias?: boolean | undefined;
+    smtpMsa?: {
+        host: string;
+        port: number;
+        securityMode: "none" | "securityModeUnspecified" | "ssl" | "starttls";
+        username?: string | undefined;
+        password?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const listSmimeInfo: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const listForwardingAddresses: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=settings.d.ts.map