@zapier/microsoft-outlook-connector 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1823 @@
+// index.ts
+import { defineConnector, toFunctions } from "@zapier/connectors-sdk";
+
+// connections.ts
+import {
+  defineEnvResolver,
+  zapierConnectionResolver
+} from "@zapier/connectors-sdk";
+var IMMUTABLE_ID_PREFER = 'IdType="ImmutableId"';
+function withImmutableId(fetchImpl) {
+  return ((input, init = {}) => {
+    const headers = new Headers(init.headers ?? void 0);
+    const existing = headers.get("Prefer");
+    headers.set(
+      "Prefer",
+      existing ? `${existing}, ${IMMUTABLE_ID_PREFER}` : IMMUTABLE_ID_PREFER
+    );
+    return fetchImpl(input, { ...init, headers });
+  });
+}
+function bearerFetch(token) {
+  return ((input, init = {}) => {
+    const headers = new Headers(init.headers ?? void 0);
+    headers.set("Authorization", `Bearer ${token}`);
+    return globalThis.fetch(input, { ...init, headers });
+  });
+}
+var zapierOutlookResolver = {
+  ...zapierConnectionResolver,
+  resolve: async (value) => withImmutableId(await zapierConnectionResolver.resolve(value))
+};
+var directOutlookResolver = defineEnvResolver({
+  name: "env",
+  valueDescription: "env var holding a Microsoft Graph access token, sent as `Authorization: Bearer <token>`; matches when the var is set",
+  build: (token) => withImmutableId(bearerFetch(token))
+});
+var connectionResolvers = {
+  "microsoft-outlook": [zapierOutlookResolver, directOutlookResolver]
+};
+
+// scripts/copyMessage.ts
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+// lib/graph.ts
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+function mailboxRoot(mailbox) {
+  return mailbox ? `/users/${encodeURIComponent(mailbox)}` : "/me";
+}
+function calendarRoot(mailbox, calendarId) {
+  const base = mailboxRoot(mailbox);
+  return calendarId ? `${base}/calendars/${encodeURIComponent(calendarId)}` : base;
+}
+function buildListQuery(params) {
+  const sp = new URLSearchParams();
+  if (params.limit !== void 0) sp.set("$top", String(params.limit));
+  if (params.search !== void 0) sp.set("$search", `"${params.search}"`);
+  if (params.filter !== void 0) sp.set("$filter", params.filter);
+  if (params.orderBy !== void 0) sp.set("$orderby", params.orderBy);
+  if (params.select !== void 0) sp.set("$select", params.select);
+  const qs = sp.toString();
+  return qs ? `?${qs}` : "";
+}
+function stripNullsDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => stripNullsDeep(v));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === null || v === void 0) continue;
+      out[k] = stripNullsDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+async function parseGraphResponse(res) {
+  return stripNullsDeep(await res.json());
+}
+function toListResult(payload) {
+  const p = payload ?? {};
+  const nextLink = p["@odata.nextLink"];
+  return {
+    items: (p.value ?? []).map((item) => stripNullsDeep(item)),
+    ...nextLink ? { next_cursor: nextLink } : {}
+  };
+}
+async function graphError(toolName, res) {
+  const raw = await res.text().catch(() => "");
+  let code = "";
+  let message = "";
+  if (raw) {
+    try {
+      const body = JSON.parse(raw);
+      code = body.error?.code ?? "";
+      message = body.error?.message ?? "";
+    } catch {
+      message = raw;
+    }
+  }
+  const prefix = `Microsoft Outlook ${toolName} ${res.status}`;
+  const detail = code ? `${code}: ${message}` : message || res.statusText;
+  if (res.status === 404 || code === "ErrorItemNotFound") {
+    return new Error(
+      `${prefix}: ${detail}. The id may be stale \u2014 message and event ids change when an item moves between folders. Re-fetch the id from the relevant list/get tool and retry.`
+    );
+  }
+  if (code === "ErrorInvalidIdMalformed") {
+    return new Error(
+      `${prefix}: ${detail}. One of the ids is malformed \u2014 obtain a valid id from a list or get tool.`
+    );
+  }
+  if (res.status === 403 || code === "ErrorAccessDenied") {
+    return new Error(
+      `${prefix}: ${detail}. Reconnect your Outlook account to grant the permission this action needs (shared-mailbox access also requires Exchange-side delegation).`
+    );
+  }
+  if (res.status === 401) {
+    return new Error(
+      `${prefix}: ${detail}. The access token is invalid or expired \u2014 reconnect your Outlook account.`
+    );
+  }
+  if (res.status === 413) {
+    return new Error(
+      `${prefix}: ${detail}. Attachments must be under 3 MB and sent inline; larger files are not supported.`
+    );
+  }
+  if (res.status === 429) {
+    const retryAfter = res.headers?.get?.("Retry-After");
+    return new Error(
+      `${prefix}: throttled by Microsoft Graph${retryAfter ? ` \u2014 retry after ${retryAfter}s` : ""}. ${message}`.trim()
+    );
+  }
+  return new Error(`${prefix}: ${detail}`);
+}
+async function outlookFetch(fetch, toolName, url, init = {}) {
+  const headers = new Headers(init.headers);
+  if (init.body !== void 0 && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  const res = await fetch(url, { ...init, headers });
+  if (!res.ok) throw await graphError(toolName, res);
+  return res;
+}
+
+// scripts/copyMessage.ts
+var inputSchema = z.object({
+  messageId: z.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  destinationId: z.string().describe(
+    "Target folder: a folder id from listMailFolders, or a well-known name (inbox, archive, deleteditems, junkemail, drafts, sentitems)."
+  ),
+  mailbox: z.string().describe(
+    "Shared-mailbox address (UPN/email) to copy within instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema = z.object({
+  id: z.string(),
+  parentFolderId: z.string(),
+  subject: z.string()
+});
+var definition = defineTool({
+  name: "copyMessage",
+  title: "Copy Message",
+  description: "Copy a message into another folder, leaving the original in place. Resolve the message id via listMessages first. Returns the new copy, which has its own id distinct from the original.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/copy`;
+    const res = await outlookFetch(ctx.fetch, "copyMessage", url, {
+      method: "POST",
+      body: JSON.stringify({ destinationId: input.destinationId })
+    });
+    return parseGraphResponse(res);
+  }
+});
+var copyMessage_default = definition;
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });
+
+// scripts/createContact.ts
+import { defineTool as defineTool2, handleIfScriptMain as handleIfScriptMain2 } from "@zapier/connectors-sdk";
+import { z as z3 } from "zod";
+
+// lib/schemas.ts
+import { z as z2 } from "zod";
+var emailAddressSchema = z2.object({
+  address: z2.string().describe("Email address, e.g. jane@contoso.com."),
+  name: z2.string().optional().describe("Display name, when known.")
+});
+var recipientSchema = z2.object({
+  emailAddress: emailAddressSchema
+});
+var dateTimeTimeZoneSchema = z2.object({
+  dateTime: z2.string().describe("Local date-time without offset, e.g. 2026-07-01T15:30:00."),
+  timeZone: z2.string().describe(
+    "Time-zone name, e.g. Pacific Standard Time or America/Los_Angeles."
+  )
+});
+var itemBodySchema = z2.object({
+  contentType: z2.enum(["text", "html"]).describe("Body content type."),
+  content: z2.string().describe("Body content, as text or HTML.")
+});
+var followupFlagSchema = z2.object({
+  flagStatus: z2.enum(["notFlagged", "flagged", "complete"]).describe("Follow-up flag state."),
+  startDateTime: dateTimeTimeZoneSchema.optional(),
+  dueDateTime: dateTimeTimeZoneSchema.optional()
+});
+var locationSchema = z2.object({
+  displayName: z2.string().optional().describe("Location name.")
+});
+var attendeeSchema = z2.object({
+  emailAddress: emailAddressSchema,
+  type: z2.string().optional().describe("Attendee type: required, optional, or resource."),
+  status: z2.object({
+    response: z2.string().optional().describe(
+      "Response: none, accepted, tentativelyAccepted, declined, organizer."
+    ),
+    time: z2.string().optional()
+  }).optional()
+});
+var messageListItemSchema = z2.object({
+  id: z2.string(),
+  subject: z2.string(),
+  bodyPreview: z2.string().optional().describe(
+    "First ~255 chars of the body; use getMessage for the full body."
+  ),
+  from: recipientSchema.optional(),
+  receivedDateTime: z2.string().optional(),
+  isRead: z2.boolean(),
+  hasAttachments: z2.boolean().optional().describe("False when a message has only inline attachments."),
+  importance: z2.string().optional(),
+  webLink: z2.string().optional()
+});
+var messageSchema = z2.object({
+  id: z2.string(),
+  subject: z2.string(),
+  body: itemBodySchema.optional(),
+  bodyPreview: z2.string().optional(),
+  from: recipientSchema.optional(),
+  sender: recipientSchema.optional(),
+  toRecipients: z2.array(recipientSchema).optional(),
+  ccRecipients: z2.array(recipientSchema).optional(),
+  receivedDateTime: z2.string().optional(),
+  sentDateTime: z2.string().optional(),
+  isRead: z2.boolean(),
+  isDraft: z2.boolean().optional(),
+  hasAttachments: z2.boolean().optional(),
+  importance: z2.string().optional(),
+  categories: z2.array(z2.string()).optional(),
+  flag: followupFlagSchema.optional(),
+  parentFolderId: z2.string().optional(),
+  internetMessageId: z2.string().optional().describe("The RFC 2822 Internet message id."),
+  conversationId: z2.string().optional(),
+  webLink: z2.string().optional()
+});
+var attachmentBaseSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  contentType: z2.string().optional(),
+  size: z2.number().optional().describe("Size in bytes."),
+  type: z2.string().optional().describe('Attachment kind: "file", "item", or "reference".')
+});
+function attachmentKind(odataType) {
+  if (typeof odataType !== "string") return void 0;
+  const match = /#microsoft\.graph\.(file|item|reference)Attachment/i.exec(
+    odataType
+  );
+  return match ? match[1].toLowerCase() : void 0;
+}
+function normalizeAttachment(attachment) {
+  return { ...attachment, type: attachmentKind(attachment["@odata.type"]) };
+}
+var attachmentListItemSchema = attachmentBaseSchema.extend({
+  isInline: z2.boolean().optional()
+});
+var attachmentSchema = attachmentBaseSchema.extend({
+  contentBytes: z2.string().optional().describe("Base64 content \u2014 present only for file attachments.")
+});
+var eventListItemSchema = z2.object({
+  id: z2.string(),
+  subject: z2.string(),
+  start: dateTimeTimeZoneSchema.optional(),
+  end: dateTimeTimeZoneSchema.optional(),
+  isAllDay: z2.boolean().optional(),
+  location: locationSchema.optional(),
+  organizer: recipientSchema.optional(),
+  type: z2.string().optional().describe("singleInstance, seriesMaster, occurrence, or exception."),
+  seriesMasterId: z2.string().optional().describe(
+    "For occurrences/exceptions: the id of the recurring series master."
+  ),
+  webLink: z2.string().optional()
+});
+var eventSchema = z2.object({
+  id: z2.string(),
+  subject: z2.string(),
+  body: itemBodySchema.optional(),
+  start: dateTimeTimeZoneSchema,
+  end: dateTimeTimeZoneSchema,
+  isAllDay: z2.boolean().optional(),
+  location: locationSchema.optional(),
+  organizer: recipientSchema.optional(),
+  attendees: z2.array(attendeeSchema).optional(),
+  isOnlineMeeting: z2.boolean().optional(),
+  onlineMeeting: z2.object({ joinUrl: z2.string().optional() }).optional().describe("Online-meeting join details, when the event has one."),
+  showAs: z2.string().optional().describe("free, tentative, busy, oof, workingElsewhere, or unknown."),
+  type: z2.string().optional(),
+  seriesMasterId: z2.string().optional(),
+  categories: z2.array(z2.string()).optional(),
+  webLink: z2.string().optional()
+});
+var emailAddressInputSchema = z2.strictObject({
+  address: z2.string().describe("Email address, e.g. jane@contoso.com."),
+  name: z2.string().describe("Display name, optional.").optional()
+});
+var recipientInputSchema = z2.strictObject({
+  emailAddress: emailAddressInputSchema
+});
+var dateTimeTimeZoneInputSchema = z2.strictObject({
+  dateTime: z2.string().describe(
+    "Naive local date-time, no trailing Z or offset, e.g. 2026-07-01T15:30:00. The zone goes in timeZone, not here."
+  ),
+  timeZone: z2.string().describe(
+    "Time-zone name, e.g. Pacific Standard Time or America/Los_Angeles. Prefer an IANA name for correct DST."
+  )
+});
+var fileAttachmentInputSchema = z2.strictObject({
+  name: z2.string().describe('File name shown in the email, e.g. "report.pdf".'),
+  contentType: z2.string().describe('MIME type, e.g. "application/pdf".').optional(),
+  contentBytes: z2.string().describe(
+    "Base64-encoded file bytes (no data: prefix). Decoded size must be under 3 MB."
+  )
+});
+var outgoingMessageSchema = z2.strictObject({
+  subject: z2.string().describe("Subject line."),
+  body: z2.strictObject({
+    contentType: z2.enum(["text", "html"]).describe("Body format. Defaults to text.").optional(),
+    content: z2.string().describe("Body text or HTML.")
+  }).describe("Message body.").optional(),
+  toRecipients: z2.array(recipientInputSchema).describe(
+    'Primary recipients, e.g. [{ "emailAddress": { "address": "jane@contoso.com" } }].'
+  ),
+  ccRecipients: z2.array(recipientInputSchema).describe("Cc recipients.").optional(),
+  bccRecipients: z2.array(recipientInputSchema).describe("Bcc recipients.").optional(),
+  importance: z2.enum(["low", "normal", "high"]).describe("Importance level. Defaults to normal.").optional(),
+  attachments: z2.array(fileAttachmentInputSchema).describe("Inline file attachments, each under 3 MB.").optional()
+});
+function toGraphOutgoingMessage(message) {
+  if (!message.attachments?.length) return message;
+  return {
+    ...message,
+    attachments: message.attachments.map((attachment) => ({
+      "@odata.type": "#microsoft.graph.fileAttachment",
+      ...attachment
+    }))
+  };
+}
+var attendeeInputSchema = z2.strictObject({
+  emailAddress: emailAddressInputSchema,
+  type: z2.enum(["required", "optional", "resource"]).describe("Attendee type. Defaults to required.").optional()
+});
+var outgoingEventSchema = z2.strictObject({
+  subject: z2.string().describe("Event title."),
+  start: dateTimeTimeZoneInputSchema.describe("Start date-time and time zone."),
+  end: dateTimeTimeZoneInputSchema.describe("End date-time and time zone."),
+  body: z2.strictObject({
+    contentType: z2.enum(["text", "html"]).describe("Body format. Defaults to text.").optional(),
+    content: z2.string().describe("Body text or HTML.")
+  }).describe("Event body / description.").optional(),
+  isAllDay: z2.boolean().describe(
+    "All-day event. Set start and end to midnight in the same time zone; end is midnight of the day AFTER the last day."
+  ).optional(),
+  location: z2.strictObject({ displayName: z2.string().describe("Location name.") }).describe("Event location.").optional(),
+  attendees: z2.array(attendeeInputSchema).describe("Attendees. Replaces the existing list on updateEvent.").optional(),
+  isOnlineMeeting: z2.boolean().describe(
+    "Add a Teams online meeting (Microsoft Graph populates the join URL)."
+  ).optional(),
+  showAs: z2.enum(["free", "tentative", "busy", "oof", "workingElsewhere", "unknown"]).describe("Free/busy status to show.").optional(),
+  sensitivity: z2.enum(["normal", "personal", "private", "confidential"]).describe("Event sensitivity.").optional(),
+  reminderMinutesBeforeStart: z2.number().int().describe("Minutes before start to remind.").optional(),
+  categories: z2.array(z2.string()).describe("Category names (see listCategories).").optional()
+});
+var outgoingContactSchema = z2.strictObject({
+  givenName: z2.string().describe("First name.").optional(),
+  surname: z2.string().describe("Last name.").optional(),
+  displayName: z2.string().describe("Full display name.").optional(),
+  companyName: z2.string().describe("Company name.").optional(),
+  jobTitle: z2.string().describe("Job title.").optional(),
+  emailAddresses: z2.array(emailAddressInputSchema).max(3).describe("Email addresses (Microsoft allows a maximum of 3).").optional(),
+  businessPhones: z2.array(z2.string()).describe("Business phone numbers.").optional(),
+  mobilePhone: z2.string().describe("Mobile phone number.").optional()
+});
+var contactSchema = z2.object({
+  id: z2.string(),
+  displayName: z2.string().optional(),
+  givenName: z2.string().optional(),
+  surname: z2.string().optional(),
+  companyName: z2.string().optional(),
+  jobTitle: z2.string().optional(),
+  emailAddresses: z2.array(emailAddressSchema).optional(),
+  businessPhones: z2.array(z2.string()).optional(),
+  mobilePhone: z2.string().optional()
+});
+
+// scripts/createContact.ts
+var inputSchema2 = z3.object({ ...outgoingContactSchema.shape }).strict();
+var outputSchema2 = contactSchema;
+var definition2 = defineTool2({
+  name: "createContact",
+  title: "Create Contact",
+  description: "Create a personal contact. No single field is required, but set at least a name (givenName/surname/displayName) or an email address so the contact is identifiable. Microsoft allows a maximum of 3 email addresses per contact.",
+  inputSchema: inputSchema2,
+  outputSchema: outputSchema2,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}/me/contacts`;
+    const res = await outlookFetch(ctx.fetch, "createContact", url, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return parseGraphResponse(res);
+  }
+});
+var createContact_default = definition2;
+await handleIfScriptMain2(import.meta, definition2, { connectionResolvers });
+
+// scripts/createDraft.ts
+import { defineTool as defineTool3, handleIfScriptMain as handleIfScriptMain3 } from "@zapier/connectors-sdk";
+import { z as z4 } from "zod";
+var inputSchema3 = z4.object({
+  ...outgoingMessageSchema.shape,
+  mailbox: z4.string().describe(
+    "Shared-mailbox address (UPN/email) to draft in instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit to draft in your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema3 = z4.object({
+  id: z4.string().describe("Draft id \u2014 pass to sendDraft to send it later."),
+  subject: z4.string(),
+  isDraft: z4.boolean(),
+  bodyPreview: z4.string().optional().describe(
+    "First ~255 chars of the body; use getMessage for the full body."
+  ),
+  toRecipients: z4.array(recipientSchema).optional(),
+  webLink: z4.string().optional()
+});
+var definition3 = defineTool3({
+  name: "createDraft",
+  title: "Create Draft",
+  description: "Compose an email and save it as a draft without sending. Returns the draft's id \u2014 the id-bearing path: pair with sendDraft when you need to reference or send the message later, or leave the draft for a human to review. Use sendMail to compose and send in one step (no id returned).",
+  inputSchema: inputSchema3,
+  outputSchema: outputSchema3,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const { mailbox, ...message } = input;
+    const url = `${GRAPH_BASE}${mailboxRoot(mailbox)}/messages`;
+    const res = await outlookFetch(ctx.fetch, "createDraft", url, {
+      method: "POST",
+      body: JSON.stringify(toGraphOutgoingMessage(message))
+    });
+    return parseGraphResponse(res);
+  }
+});
+var createDraft_default = definition3;
+await handleIfScriptMain3(import.meta, definition3, { connectionResolvers });
+
+// scripts/createEvent.ts
+import { defineTool as defineTool4, handleIfScriptMain as handleIfScriptMain4 } from "@zapier/connectors-sdk";
+import { z as z5 } from "zod";
+var inputSchema4 = z5.object({
+  ...outgoingEventSchema.shape,
+  mailbox: z5.string().describe(
+    "Shared-mailbox address (UPN/email) to create the event in instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z5.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional()
+}).strict();
+var outputSchema4 = eventSchema;
+var definition4 = defineTool4({
+  name: "createEvent",
+  title: "Create Event",
+  description: "Create a calendar event. Targets the default calendar unless calendarId is set. start and end are { dateTime, timeZone } objects where dateTime is a naive local timestamp (no trailing Z or offset). For an all-day event set isAllDay with start/end at midnight in the same time zone (end is midnight of the day AFTER the last day). Set isOnlineMeeting to add a Teams online meeting.",
+  inputSchema: inputSchema4,
+  outputSchema: outputSchema4,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const { mailbox, calendarId, ...event } = input;
+    const url = `${GRAPH_BASE}${calendarRoot(mailbox, calendarId)}/events`;
+    const res = await outlookFetch(ctx.fetch, "createEvent", url, {
+      method: "POST",
+      body: JSON.stringify(event)
+    });
+    return parseGraphResponse(res);
+  }
+});
+var createEvent_default = definition4;
+await handleIfScriptMain4(import.meta, definition4, { connectionResolvers });
+
+// scripts/createMailFolder.ts
+import { defineTool as defineTool5, handleIfScriptMain as handleIfScriptMain5 } from "@zapier/connectors-sdk";
+import { z as z6 } from "zod";
+var inputSchema5 = z6.object({
+  displayName: z6.string().describe("Folder name as shown in Outlook."),
+  parentFolderId: z6.string().describe(
+    "Set a folder id (or well-known name from listMailFolders) to create the folder as a subfolder of it. Omit to create at the top level."
+  ).optional(),
+  mailbox: z6.string().describe(
+    "Shared-mailbox address (UPN/email) to create the folder in instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema5 = z6.object({
+  id: z6.string(),
+  displayName: z6.string(),
+  parentFolderId: z6.string().optional()
+});
+var definition5 = defineTool5({
+  name: "createMailFolder",
+  title: "Create Mail Folder",
+  description: "Create a mail folder, returning its id. Creates a top-level folder by default, or a subfolder when parentFolderId is set (resolve the parent id via listMailFolders). Use the returned id as folderId/destinationId in other mail tools.",
+  inputSchema: inputSchema5,
+  outputSchema: outputSchema5,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const root = mailboxRoot(input.mailbox);
+    const path = input.parentFolderId !== void 0 ? `${root}/mailFolders/${encodeURIComponent(input.parentFolderId)}/childFolders` : `${root}/mailFolders`;
+    const url = `${GRAPH_BASE}${path}`;
+    const res = await outlookFetch(ctx.fetch, "createMailFolder", url, {
+      method: "POST",
+      body: JSON.stringify({ displayName: input.displayName })
+    });
+    return parseGraphResponse(res);
+  }
+});
+var createMailFolder_default = definition5;
+await handleIfScriptMain5(import.meta, definition5, { connectionResolvers });
+
+// scripts/createReplyDraft.ts
+import { defineTool as defineTool6, handleIfScriptMain as handleIfScriptMain6 } from "@zapier/connectors-sdk";
+import { z as z7 } from "zod";
+var inputSchema6 = z7.object({
+  messageId: z7.string().describe(
+    "Id of the message to reply to, from listMessages or getMessage. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  comment: z7.string().describe(
+    "Reply text to seed the draft body, above the quoted original. Plain text or HTML."
+  ).optional(),
+  replyAll: z7.boolean().describe(
+    "Draft a reply to all original recipients (To + Cc) instead of just the sender. Defaults to false."
+  ).optional(),
+  mailbox: z7.string().describe(
+    "Shared-mailbox address (UPN/email) to draft the reply in instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema6 = z7.object({
+  id: z7.string().describe("Draft reply id \u2014 edit further or pass to sendDraft."),
+  subject: z7.string(),
+  isDraft: z7.boolean(),
+  webLink: z7.string().optional()
+});
+var definition6 = defineTool6({
+  name: "createReplyDraft",
+  title: "Create Reply Draft",
+  description: "Create a draft reply (not sent), pre-populated with the original recipients and quoted body. Set replyAll to draft a reply to all original recipients (To + Cc). Returns the draft's id \u2014 review/edit it, then send with sendDraft. Resolve the message id via listMessages first; to reply and send in one step, use replyToMessage.",
+  inputSchema: inputSchema6,
+  outputSchema: outputSchema6,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const action = input.replyAll ? "createReplyAll" : "createReply";
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/${action}`;
+    const res = await outlookFetch(ctx.fetch, "createReplyDraft", url, {
+      method: "POST",
+      body: JSON.stringify(
+        input.comment !== void 0 ? { comment: input.comment } : {}
+      )
+    });
+    return parseGraphResponse(res);
+  }
+});
+var createReplyDraft_default = definition6;
+await handleIfScriptMain6(import.meta, definition6, { connectionResolvers });
+
+// scripts/deleteContact.ts
+import { defineTool as defineTool7, handleIfScriptMain as handleIfScriptMain7 } from "@zapier/connectors-sdk";
+import { z as z8 } from "zod";
+var inputSchema7 = z8.object({
+  contactId: z8.string().describe("Contact id from listContacts. Opaque and case-sensitive.")
+}).strict();
+var outputSchema7 = z8.object({
+  success: z8.literal(true)
+});
+var definition7 = defineTool7({
+  name: "deleteContact",
+  title: "Delete Contact",
+  description: "Delete a personal contact by id. This cannot be undone \u2014 resolve the id via listContacts and confirm it's the right contact first.",
+  inputSchema: inputSchema7,
+  outputSchema: outputSchema7,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}/me/contacts/${encodeURIComponent(
+      input.contactId
+    )}`;
+    await outlookFetch(ctx.fetch, "deleteContact", url, { method: "DELETE" });
+    return { success: true };
+  }
+});
+var deleteContact_default = definition7;
+await handleIfScriptMain7(import.meta, definition7, { connectionResolvers });
+
+// scripts/deleteEvent.ts
+import { defineTool as defineTool8, handleIfScriptMain as handleIfScriptMain8 } from "@zapier/connectors-sdk";
+import { z as z9 } from "zod";
+var inputSchema8 = z9.object({
+  eventId: z9.string().describe(
+    "Opaque event id from listEvents, listCalendarView, or getEvent."
+  ),
+  mailbox: z9.string().describe(
+    "Shared-mailbox address (UPN/email) holding the event instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z9.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional()
+}).strict();
+var outputSchema8 = z9.object({
+  success: z9.literal(true)
+});
+var definition8 = defineTool8({
+  name: "deleteEvent",
+  title: "Delete Event",
+  description: "Delete (cancel) a calendar event. For events you organize, attendees are notified of the cancellation \u2014 this is not trivially reversible.",
+  inputSchema: inputSchema8,
+  outputSchema: outputSchema8,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${calendarRoot(input.mailbox, input.calendarId)}/events/${encodeURIComponent(
+      input.eventId
+    )}`;
+    await outlookFetch(ctx.fetch, "deleteEvent", url, { method: "DELETE" });
+    return { success: true };
+  }
+});
+var deleteEvent_default = definition8;
+await handleIfScriptMain8(import.meta, definition8, { connectionResolvers });
+
+// scripts/deleteMessage.ts
+import { defineTool as defineTool9, handleIfScriptMain as handleIfScriptMain9 } from "@zapier/connectors-sdk";
+import { z as z10 } from "zod";
+var inputSchema9 = z10.object({
+  messageId: z10.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  mailbox: z10.string().describe(
+    "Shared-mailbox address (UPN/email) to delete from instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema9 = z10.object({
+  success: z10.literal(true)
+});
+var definition9 = defineTool9({
+  name: "deleteMessage",
+  title: "Delete Message",
+  description: "Soft-delete a message: it moves to the Deleted Items folder and is reversible (move it back out to restore). Resolve the message id via listMessages first.",
+  inputSchema: inputSchema9,
+  outputSchema: outputSchema9,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}`;
+    await outlookFetch(ctx.fetch, "deleteMessage", url, {
+      method: "DELETE"
+    });
+    return { success: true };
+  }
+});
+var deleteMessage_default = definition9;
+await handleIfScriptMain9(import.meta, definition9, { connectionResolvers });
+
+// scripts/forwardMessage.ts
+import { defineTool as defineTool10, handleIfScriptMain as handleIfScriptMain10 } from "@zapier/connectors-sdk";
+import { z as z11 } from "zod";
+var inputSchema10 = z11.object({
+  messageId: z11.string().describe(
+    "Id of the message to forward, from listMessages or getMessage. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  toRecipients: z11.array(recipientInputSchema).min(1).describe(
+    'Who to forward the message to, e.g. [{ "emailAddress": { "address": "jane@contoso.com" } }].'
+  ),
+  comment: z11.string().describe(
+    "Note prepended above the forwarded original. Plain text or HTML."
+  ).optional(),
+  mailbox: z11.string().describe(
+    "Shared-mailbox address (UPN/email) to forward from instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit to forward as yourself."
+  ).optional()
+}).strict();
+var outputSchema10 = z11.object({
+  success: z11.literal(true)
+});
+var definition10 = defineTool10({
+  name: "forwardMessage",
+  title: "Forward Message",
+  description: "Forward a message to new recipients and send immediately, quoting the original. Returns only a success flag (202 accepted, no id). Resolve the message id via listMessages first.",
+  inputSchema: inputSchema10,
+  outputSchema: outputSchema10,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/forward`;
+    const body = {
+      toRecipients: input.toRecipients,
+      ...input.comment !== void 0 ? { comment: input.comment } : {}
+    };
+    await outlookFetch(ctx.fetch, "forwardMessage", url, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return { success: true };
+  }
+});
+var forwardMessage_default = definition10;
+await handleIfScriptMain10(import.meta, definition10, { connectionResolvers });
+
+// scripts/getAttachment.ts
+import { defineTool as defineTool11, handleIfScriptMain as handleIfScriptMain11 } from "@zapier/connectors-sdk";
+import { z as z12 } from "zod";
+var inputSchema11 = z12.object({
+  messageId: z12.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  attachmentId: z12.string().describe("Attachment id from listAttachments."),
+  mailbox: z12.string().describe(
+    "Shared-mailbox address (UPN/email) to read from instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema11 = attachmentSchema;
+var definition11 = defineTool11({
+  name: "getAttachment",
+  title: "Get Attachment",
+  description: "Retrieve one attachment by id, including its base64 contentBytes. Resolve the attachmentId via listAttachments first. contentBytes is present only for file attachments \u2014 item and reference attachments carry no inline bytes.",
+  inputSchema: inputSchema11,
+  outputSchema: outputSchema11,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/attachments/${encodeURIComponent(input.attachmentId)}`;
+    const res = await outlookFetch(ctx.fetch, "getAttachment", url);
+    return normalizeAttachment(
+      await parseGraphResponse(res)
+    );
+  }
+});
+var getAttachment_default = definition11;
+await handleIfScriptMain11(import.meta, definition11, { connectionResolvers });
+
+// scripts/getContact.ts
+import { defineTool as defineTool12, handleIfScriptMain as handleIfScriptMain12 } from "@zapier/connectors-sdk";
+import { z as z13 } from "zod";
+var inputSchema12 = z13.object({
+  contactId: z13.string().describe("Contact id from listContacts. Opaque and case-sensitive.")
+}).strict();
+var outputSchema12 = contactSchema;
+var definition12 = defineTool12({
+  name: "getContact",
+  title: "Get Contact",
+  description: "Retrieve a single personal contact by id, including names, company, email addresses, and phone numbers. Resolve the id via listContacts first. The resolver getter for updateContact.",
+  inputSchema: inputSchema12,
+  outputSchema: outputSchema12,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}/me/contacts/${encodeURIComponent(
+      input.contactId
+    )}`;
+    const res = await outlookFetch(ctx.fetch, "getContact", url);
+    return parseGraphResponse(res);
+  }
+});
+var getContact_default = definition12;
+await handleIfScriptMain12(import.meta, definition12, { connectionResolvers });
+
+// scripts/getEvent.ts
+import { defineTool as defineTool13, handleIfScriptMain as handleIfScriptMain13 } from "@zapier/connectors-sdk";
+import { z as z14 } from "zod";
+var inputSchema13 = z14.object({
+  eventId: z14.string().describe(
+    "Opaque event id from listEvents, listCalendarView, or getEvent."
+  ),
+  mailbox: z14.string().describe(
+    "Shared-mailbox address (UPN/email) to read from instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z14.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional()
+}).strict();
+var outputSchema13 = eventSchema;
+var definition13 = defineTool13({
+  name: "getEvent",
+  title: "Get Event",
+  description: "Retrieve a single calendar event by id, including attendees, body, and online-meeting details. Resolve the id via listEvents or listCalendarView first. Use this to read the current state before updateEvent (read-modify-write \u2014 e.g. fetch the attendees, append, then update).",
+  inputSchema: inputSchema13,
+  outputSchema: outputSchema13,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${calendarRoot(input.mailbox, input.calendarId)}/events/${encodeURIComponent(
+      input.eventId
+    )}`;
+    const res = await outlookFetch(ctx.fetch, "getEvent", url);
+    return parseGraphResponse(res);
+  }
+});
+var getEvent_default = definition13;
+await handleIfScriptMain13(import.meta, definition13, { connectionResolvers });
+
+// scripts/getMe.ts
+import { defineTool as defineTool14, handleIfScriptMain as handleIfScriptMain14 } from "@zapier/connectors-sdk";
+import { z as z15 } from "zod";
+var inputSchema14 = z15.object({}).strict();
+var outputSchema14 = z15.object({
+  id: z15.string(),
+  displayName: z15.string().optional(),
+  mail: z15.string().optional(),
+  userPrincipalName: z15.string(),
+  jobTitle: z15.string().optional(),
+  mobilePhone: z15.string().optional()
+});
+var definition14 = defineTool14({
+  name: "getMe",
+  title: "Get Me",
+  description: `Retrieve the signed-in user's profile \u2014 id, displayName, mail, and userPrincipalName. Doubles as the auth probe (a 200 confirms the connection works). Call this first to resolve "my email" before composing or filtering mail.`,
+  inputSchema: inputSchema14,
+  outputSchema: outputSchema14,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (_input, ctx) => {
+    const url = `${GRAPH_BASE}/me`;
+    const res = await outlookFetch(ctx.fetch, "getMe", url);
+    return parseGraphResponse(res);
+  }
+});
+var getMe_default = definition14;
+await handleIfScriptMain14(import.meta, definition14, { connectionResolvers });
+
+// scripts/getMessage.ts
+import { defineTool as defineTool15, handleIfScriptMain as handleIfScriptMain15 } from "@zapier/connectors-sdk";
+import { z as z16 } from "zod";
+var inputSchema15 = z16.object({
+  messageId: z16.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  bodyContentType: z16.enum(["text", "html"]).describe(
+    "Format for the returned body. Defaults to text (smaller, keeps visible URLs); pass html to preserve formatting."
+  ).optional(),
+  mailbox: z16.string().describe(
+    "Shared-mailbox address (UPN/email) to read from instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema15 = messageSchema;
+var definition15 = defineTool15({
+  name: "getMessage",
+  title: "Get Message",
+  description: "Retrieve a single message by id, including its full body, recipient lists, flag, and categories. Resolve the id via listMessages first. The body is returned as plain text by default; pass bodyContentType: html for the original markup.",
+  inputSchema: inputSchema15,
+  outputSchema: outputSchema15,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}`;
+    const res = await outlookFetch(ctx.fetch, "getMessage", url, {
+      headers: {
+        Prefer: `outlook.body-content-type="${input.bodyContentType ?? "text"}"`
+      }
+    });
+    return parseGraphResponse(res);
+  }
+});
+var getMessage_default = definition15;
+await handleIfScriptMain15(import.meta, definition15, { connectionResolvers });
+
+// scripts/listAttachments.ts
+import { defineTool as defineTool16, handleIfScriptMain as handleIfScriptMain16 } from "@zapier/connectors-sdk";
+import { z as z17 } from "zod";
+var inputSchema16 = z17.object({
+  messageId: z17.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  mailbox: z17.string().describe(
+    "Shared-mailbox address (UPN/email) to read from instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  limit: z17.number().int().gte(1).describe(
+    "Attachments per page. Defaults to 20 when omitted; pass a value when you need a specific number."
+  ).optional(),
+  cursor: z17.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema16 = z17.object({
+  items: z17.array(attachmentListItemSchema),
+  next_cursor: z17.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition16 = defineTool16({
+  name: "listAttachments",
+  title: "List Attachments",
+  description: "List the attachments on a message \u2014 name, content type, size, kind, and inline flag. Resolve the messageId via listMessages first, then use getAttachment to download a specific one's bytes. A message's hasAttachments is false when it has only inline attachments, so still call this to check for them.",
+  inputSchema: inputSchema16,
+  outputSchema: outputSchema16,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const path = `${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+        input.messageId
+      )}/attachments`;
+      const query = buildListQuery({ limit: input.limit ?? 20 });
+      url = `${GRAPH_BASE}${path}${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listAttachments", url);
+    const result = toListResult(await res.json());
+    return {
+      ...result,
+      items: result.items.map((item) => normalizeAttachment(item))
+    };
+  }
+});
+var listAttachments_default = definition16;
+await handleIfScriptMain16(import.meta, definition16, { connectionResolvers });
+
+// scripts/listCalendars.ts
+import { defineTool as defineTool17, handleIfScriptMain as handleIfScriptMain17 } from "@zapier/connectors-sdk";
+import { z as z18 } from "zod";
+var inputSchema17 = z18.object({
+  mailbox: z18.string().describe(
+    "Shared-mailbox address (UPN/email) to read instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  limit: z18.number().int().gte(1).describe(
+    "Calendars per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  cursor: z18.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema17 = z18.object({
+  items: z18.array(
+    z18.object({
+      id: z18.string(),
+      name: z18.string(),
+      isDefaultCalendar: z18.boolean().optional(),
+      canEdit: z18.boolean().optional()
+    })
+  ),
+  next_cursor: z18.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition17 = defineTool17({
+  name: "listCalendars",
+  title: "List Calendars",
+  description: "List the available calendars in a mailbox. The entry point for resolving a calendarId to pass to the event tools (listEvents, listCalendarView, createEvent, ...); omit calendarId on those tools to use the default calendar.",
+  inputSchema: inputSchema17,
+  outputSchema: outputSchema17,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const query = buildListQuery({ limit: input.limit ?? 20 });
+      url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/calendars${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listCalendars", url);
+    return toListResult(await res.json());
+  }
+});
+var listCalendars_default = definition17;
+await handleIfScriptMain17(import.meta, definition17, { connectionResolvers });
+
+// scripts/listCalendarView.ts
+import { defineTool as defineTool18, handleIfScriptMain as handleIfScriptMain18 } from "@zapier/connectors-sdk";
+import { z as z19 } from "zod";
+var inputSchema18 = z19.object({
+  startDateTime: z19.string().describe(
+    'Window start, ISO 8601 (e.g. "2026-07-01T00:00:00"). Interpreted as UTC unless it carries an offset.'
+  ),
+  endDateTime: z19.string().describe(
+    "Window end, ISO 8601. Interpreted as UTC unless it carries an offset."
+  ),
+  mailbox: z19.string().describe(
+    "Shared-mailbox address (UPN/email) to read instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z19.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional(),
+  limit: z19.number().int().gte(1).describe(
+    "Events per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  cursor: z19.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema18 = z19.object({
+  items: z19.array(eventListItemSchema),
+  next_cursor: z19.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition18 = defineTool18({
+  name: "listCalendarView",
+  title: "List Calendar View",
+  description: `The primary "what's on my calendar" tool: list everything occurring between startDateTime and endDateTime, expanding recurring series into their individual occurrences. Targets the default calendar unless calendarId is set.`,
+  inputSchema: inputSchema18,
+  outputSchema: outputSchema18,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const sp = new URLSearchParams();
+      sp.set("startDateTime", input.startDateTime);
+      sp.set("endDateTime", input.endDateTime);
+      sp.set("$top", String(input.limit ?? 20));
+      url = `${GRAPH_BASE}${calendarRoot(input.mailbox, input.calendarId)}/calendarView?${sp.toString()}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listCalendarView", url);
+    return toListResult(await res.json());
+  }
+});
+var listCalendarView_default = definition18;
+await handleIfScriptMain18(import.meta, definition18, { connectionResolvers });
+
+// scripts/listCategories.ts
+import { defineTool as defineTool19, handleIfScriptMain as handleIfScriptMain19 } from "@zapier/connectors-sdk";
+import { z as z20 } from "zod";
+var inputSchema19 = z20.object({}).strict();
+var outputSchema19 = z20.object({
+  items: z20.array(
+    z20.object({
+      id: z20.string().optional(),
+      displayName: z20.string(),
+      color: z20.string().describe('Preset color name, e.g. "preset0".').optional()
+    })
+  )
+});
+var definition19 = defineTool19({
+  name: "listCategories",
+  title: "List Categories",
+  description: "List the signed-in user's category names and colors. A discovery tool for the valid category names passed to updateMessage or createEvent \u2014 a category's color comes from the user's master list (you apply a category by its displayName). Only your own categories (no mailbox option).",
+  inputSchema: inputSchema19,
+  outputSchema: outputSchema19,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (_input, ctx) => {
+    const url = `${GRAPH_BASE}/me/outlook/masterCategories`;
+    const res = await outlookFetch(ctx.fetch, "listCategories", url);
+    const body = await res.json();
+    return { items: (body.value ?? []).map((c) => stripNullsDeep(c)) };
+  }
+});
+var listCategories_default = definition19;
+await handleIfScriptMain19(import.meta, definition19, { connectionResolvers });
+
+// scripts/listContacts.ts
+import { defineTool as defineTool20, handleIfScriptMain as handleIfScriptMain20 } from "@zapier/connectors-sdk";
+import { z as z21 } from "zod";
+var inputSchema20 = z21.object({
+  filter: z21.string().describe(
+    `OData $filter predicate. Only the email-match form is supported server-side, e.g. "emailAddresses/any(a:a/address eq 'jane@contoso.com')". Name search is NOT filterable \u2014 list and filter the returned results client-side instead. Omit to list all contacts.`
+  ).optional(),
+  limit: z21.number().int().gte(1).describe(
+    "Contacts per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  cursor: z21.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema20 = z21.object({
+  items: z21.array(contactSchema),
+  next_cursor: z21.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition20 = defineTool20({
+  name: "listContacts",
+  title: "List Contacts",
+  description: `List or search the user's personal contacts. Use filter to match by email, e.g. "emailAddresses/any(a:a/address eq 'jane@contoso.com')"; name search isn't filterable server-side, so list and match the returned results yourself. The entry point for resolving a contact id before getContact/updateContact/deleteContact.`,
+  inputSchema: inputSchema20,
+  outputSchema: outputSchema20,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const query = buildListQuery({
+        limit: input.limit ?? 20,
+        filter: input.filter
+      });
+      url = `${GRAPH_BASE}/me/contacts${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listContacts", url);
+    return toListResult(await res.json());
+  }
+});
+var listContacts_default = definition20;
+await handleIfScriptMain20(import.meta, definition20, { connectionResolvers });
+
+// scripts/listEvents.ts
+import { defineTool as defineTool21, handleIfScriptMain as handleIfScriptMain21 } from "@zapier/connectors-sdk";
+import { z as z22 } from "zod";
+var inputSchema21 = z22.object({
+  filter: z22.string().describe(
+    `OData $filter predicate for exact matches, e.g. "subject eq 'Standup'" or "showAs eq 'busy'". Omit to list all events.`
+  ).optional(),
+  mailbox: z22.string().describe(
+    "Shared-mailbox address (UPN/email) to read instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z22.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional(),
+  limit: z22.number().int().gte(1).describe(
+    "Events per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  cursor: z22.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema21 = z22.object({
+  items: z22.array(eventListItemSchema),
+  next_cursor: z22.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition21 = defineTool21({
+  name: "listEvents",
+  title: "List Events",
+  description: "List a calendar's events: single events plus recurring SERIES MASTERS (the recurrence definition, not expanded occurrences). Use filter for exact predicates. To see what actually occurs within a date range \u2014 including each occurrence of a recurring series \u2014 use listCalendarView instead.",
+  inputSchema: inputSchema21,
+  outputSchema: outputSchema21,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const query = buildListQuery({
+        limit: input.limit ?? 20,
+        filter: input.filter
+      });
+      url = `${GRAPH_BASE}${calendarRoot(input.mailbox, input.calendarId)}/events${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listEvents", url);
+    return toListResult(await res.json());
+  }
+});
+var listEvents_default = definition21;
+await handleIfScriptMain21(import.meta, definition21, { connectionResolvers });
+
+// scripts/listMailFolders.ts
+import { defineTool as defineTool22, handleIfScriptMain as handleIfScriptMain22 } from "@zapier/connectors-sdk";
+import { z as z23 } from "zod";
+var inputSchema22 = z23.object({
+  parentFolderId: z23.string().describe(
+    "Omit to list top-level folders. Set a folder id (from a previous call) or a well-known name (inbox, drafts, sentitems, deleteditems, archive, junkemail) to list that folder's subfolders."
+  ).optional(),
+  mailbox: z23.string().describe(
+    "Shared-mailbox address (UPN/email) to read instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  limit: z23.number().int().gte(1).describe(
+    "Folders per page. Defaults to 20 when omitted; pass a value when you need a specific number."
+  ).optional(),
+  cursor: z23.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema22 = z23.object({
+  items: z23.array(
+    z23.object({
+      id: z23.string(),
+      displayName: z23.string(),
+      parentFolderId: z23.string().optional(),
+      childFolderCount: z23.number().optional(),
+      unreadItemCount: z23.number().optional(),
+      totalItemCount: z23.number().optional()
+    })
+  ),
+  next_cursor: z23.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition22 = defineTool22({
+  name: "listMailFolders",
+  title: "List Mail Folders",
+  description: "List mail folders. Returns top-level folders by default; pass parentFolderId to list a folder's subfolders. The entry point for resolving a folder id to pass as folderId to listMessages or destinationId to moveMessage.",
+  inputSchema: inputSchema22,
+  outputSchema: outputSchema22,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const root = mailboxRoot(input.mailbox);
+      const path = input.parentFolderId !== void 0 ? `${root}/mailFolders/${encodeURIComponent(input.parentFolderId)}/childFolders` : `${root}/mailFolders`;
+      const query = buildListQuery({ limit: input.limit ?? 20 });
+      url = `${GRAPH_BASE}${path}${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listMailFolders", url);
+    return toListResult(await res.json());
+  }
+});
+var listMailFolders_default = definition22;
+await handleIfScriptMain22(import.meta, definition22, { connectionResolvers });
+
+// scripts/listMessages.ts
+import { defineTool as defineTool23, handleIfScriptMain as handleIfScriptMain23 } from "@zapier/connectors-sdk";
+import { z as z24 } from "zod";
+var inputSchema23 = z24.object({
+  folderId: z24.string().describe(
+    "Restrict to one folder: a folder id from listMailFolders, or a well-known name (inbox, drafts, sentitems, deleteditems, archive, junkemail). Omit to list across all folders."
+  ).optional(),
+  search: z24.string().describe(
+    'Full-text KQL search over the default from/subject/body properties, e.g. "subject:invoice from:acme". Results are sorted by the date and time sent. Omit to list newest-first.'
+  ).optional(),
+  filter: z24.string().describe(
+    `OData $filter predicate for exact matches, e.g. "isRead eq false" or "importance eq 'high'". Use search for free-text instead.`
+  ).optional(),
+  mailbox: z24.string().describe(
+    "Shared-mailbox address (UPN/email) to read instead of your own, e.g. team@contoso.com. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  limit: z24.number().int().gte(1).describe(
+    "Messages per page. Defaults to 10 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  cursor: z24.string().describe(
+    "Pagination cursor from a previous response's next_cursor. Omit for the first page."
+  ).optional()
+}).strict();
+var outputSchema23 = z24.object({
+  items: z24.array(messageListItemSchema),
+  next_cursor: z24.string().describe("Pass as cursor to fetch the next page. Absent on the last page.").optional()
+});
+var definition23 = defineTool23({
+  name: "listMessages",
+  title: "List Messages",
+  description: 'Search or list mailbox messages. Listing is newest-first; search results (KQL, e.g. "subject:invoice from:acme") are ordered by sent date, not recency. Scope with folderId; exact-match with filter. The entry point for resolving a message id before getMessage/updateMessage/moveMessage.',
+  inputSchema: inputSchema23,
+  outputSchema: outputSchema23,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    let url;
+    if (input.cursor !== void 0) {
+      url = input.cursor;
+    } else {
+      const root = mailboxRoot(input.mailbox);
+      const path = input.folderId !== void 0 ? `${root}/mailFolders/${encodeURIComponent(input.folderId)}/messages` : `${root}/messages`;
+      const query = buildListQuery({
+        limit: input.limit ?? 10,
+        search: input.search,
+        filter: input.filter
+      });
+      url = `${GRAPH_BASE}${path}${query}`;
+    }
+    const res = await outlookFetch(ctx.fetch, "listMessages", url);
+    return toListResult(await res.json());
+  }
+});
+var listMessages_default = definition23;
+await handleIfScriptMain23(import.meta, definition23, { connectionResolvers });
+
+// scripts/moveMessage.ts
+import { defineTool as defineTool24, handleIfScriptMain as handleIfScriptMain24 } from "@zapier/connectors-sdk";
+import { z as z25 } from "zod";
+var inputSchema24 = z25.object({
+  messageId: z25.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  destinationId: z25.string().describe(
+    "Target folder: a folder id from listMailFolders, or a well-known name (inbox, archive, deleteditems, junkemail, drafts, sentitems)."
+  ),
+  mailbox: z25.string().describe(
+    "Shared-mailbox address (UPN/email) to move within instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema24 = z25.object({
+  id: z25.string(),
+  parentFolderId: z25.string(),
+  subject: z25.string()
+});
+var definition24 = defineTool24({
+  name: "moveMessage",
+  title: "Move Message",
+  description: "Move a message into another folder. Resolve the message id via listMessages first. IMPORTANT: the message id CHANGES after a move \u2014 use the id from this response for any follow-up call, not the id you passed in.",
+  inputSchema: inputSchema24,
+  outputSchema: outputSchema24,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/move`;
+    const res = await outlookFetch(ctx.fetch, "moveMessage", url, {
+      method: "POST",
+      body: JSON.stringify({ destinationId: input.destinationId })
+    });
+    return parseGraphResponse(res);
+  }
+});
+var moveMessage_default = definition24;
+await handleIfScriptMain24(import.meta, definition24, { connectionResolvers });
+
+// scripts/replyToMessage.ts
+import { defineTool as defineTool25, handleIfScriptMain as handleIfScriptMain25 } from "@zapier/connectors-sdk";
+import { z as z26 } from "zod";
+var inputSchema25 = z26.object({
+  messageId: z26.string().describe(
+    "Id of the message to reply to, from listMessages or getMessage. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  comment: z26.string().describe(
+    "Reply text prepended above the quoted original. Plain text or HTML. Omit to send an empty-bodied reply."
+  ).optional(),
+  replyAll: z26.boolean().describe(
+    "Reply to all original recipients (To + Cc) instead of just the sender. Defaults to false."
+  ).optional(),
+  mailbox: z26.string().describe(
+    "Shared-mailbox address (UPN/email) to reply from instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit to reply as yourself."
+  ).optional()
+}).strict();
+var outputSchema25 = z26.object({
+  success: z26.literal(true)
+});
+var definition25 = defineTool25({
+  name: "replyToMessage",
+  title: "Reply To Message",
+  description: "Reply to a message and send immediately, quoting the original. Set replyAll to reply to all original recipients (To + Cc). Returns only a success flag (202 accepted, no id). Resolve the message id via listMessages first; to draft a reply for review instead, use createReplyDraft.",
+  inputSchema: inputSchema25,
+  outputSchema: outputSchema25,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const action = input.replyAll ? "replyAll" : "reply";
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/${action}`;
+    await outlookFetch(ctx.fetch, "replyToMessage", url, {
+      method: "POST",
+      body: JSON.stringify(
+        input.comment !== void 0 ? { comment: input.comment } : {}
+      )
+    });
+    return { success: true };
+  }
+});
+var replyToMessage_default = definition25;
+await handleIfScriptMain25(import.meta, definition25, { connectionResolvers });
+
+// scripts/sendDraft.ts
+import { defineTool as defineTool26, handleIfScriptMain as handleIfScriptMain26 } from "@zapier/connectors-sdk";
+import { z as z27 } from "zod";
+var inputSchema26 = z27.object({
+  messageId: z27.string().describe(
+    "Draft id from createDraft. Opaque and case-sensitive; the id is dead once the draft is sent."
+  ),
+  mailbox: z27.string().describe(
+    "Shared-mailbox address (UPN/email) the draft lives in instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema26 = z27.object({
+  success: z27.literal(true)
+});
+var definition26 = defineTool26({
+  name: "sendDraft",
+  title: "Send Draft",
+  description: "Send a draft email created by createDraft. Returns only a success flag (the send is accepted asynchronously, and 202 \u2260 delivered); the draft id is dead after sending. Resolve the draft id from createDraft first.",
+  inputSchema: inputSchema26,
+  outputSchema: outputSchema26,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}/send`;
+    await outlookFetch(ctx.fetch, "sendDraft", url, { method: "POST" });
+    return { success: true };
+  }
+});
+var sendDraft_default = definition26;
+await handleIfScriptMain26(import.meta, definition26, { connectionResolvers });
+
+// scripts/sendMail.ts
+import { defineTool as defineTool27, handleIfScriptMain as handleIfScriptMain27 } from "@zapier/connectors-sdk";
+import { z as z28 } from "zod";
+var inputSchema27 = z28.object({
+  message: outgoingMessageSchema.describe(
+    "The email to send. subject and toRecipients are required."
+  ),
+  saveToSentItems: z28.boolean().describe("Keep a copy in Sent Items. Defaults to true.").optional(),
+  mailbox: z28.string().describe(
+    "Shared-mailbox address (UPN/email) to send as instead of your own, e.g. team@contoso.com. Requires Send-as/Send-on-behalf delegation. Omit to send as yourself."
+  ).optional()
+}).strict();
+var outputSchema27 = z28.object({
+  success: z28.literal(true)
+});
+var definition27 = defineTool27({
+  name: "sendMail",
+  title: "Send Mail",
+  description: "Compose and send an email in one step. Returns only a success flag \u2014 the send is accepted asynchronously with no message id (and 202 \u2260 delivered). When you need the sent message's id, use createDraft then sendDraft instead.",
+  inputSchema: inputSchema27,
+  outputSchema: outputSchema27,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/sendMail`;
+    const body = {
+      message: toGraphOutgoingMessage(input.message)
+    };
+    if (input.saveToSentItems !== void 0) {
+      body.saveToSentItems = input.saveToSentItems;
+    }
+    await outlookFetch(ctx.fetch, "sendMail", url, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return { success: true };
+  }
+});
+var sendMail_default = definition27;
+await handleIfScriptMain27(import.meta, definition27, { connectionResolvers });
+
+// scripts/updateContact.ts
+import { defineTool as defineTool28, handleIfScriptMain as handleIfScriptMain28 } from "@zapier/connectors-sdk";
+import { z as z29 } from "zod";
+var inputSchema28 = z29.object({
+  contactId: z29.string().describe("Contact id from listContacts. Opaque and case-sensitive."),
+  ...outgoingContactSchema.shape
+}).strict();
+var outputSchema28 = contactSchema;
+var definition28 = defineTool28({
+  name: "updateContact",
+  title: "Update Contact",
+  description: "Update fields on a personal contact. Set only the fields you want to change. Array fields (emailAddresses, businessPhones) REPLACE the existing values \u2014 read current via getContact, merge, then update.",
+  inputSchema: inputSchema28,
+  outputSchema: outputSchema28,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const { contactId, ...patch } = input;
+    const url = `${GRAPH_BASE}/me/contacts/${encodeURIComponent(contactId)}`;
+    const res = await outlookFetch(ctx.fetch, "updateContact", url, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+    return parseGraphResponse(res);
+  }
+});
+var updateContact_default = definition28;
+await handleIfScriptMain28(import.meta, definition28, { connectionResolvers });
+
+// scripts/updateEvent.ts
+import { defineTool as defineTool29, handleIfScriptMain as handleIfScriptMain29 } from "@zapier/connectors-sdk";
+import { z as z30 } from "zod";
+var inputSchema29 = z30.object({
+  eventId: z30.string().describe(
+    "Opaque event id from listEvents, listCalendarView, or getEvent."
+  ),
+  ...outgoingEventSchema.partial().shape,
+  mailbox: z30.string().describe(
+    "Shared-mailbox address (UPN/email) holding the event instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional(),
+  calendarId: z30.string().describe(
+    "Target a specific calendar (id from listCalendars). Omit to use the default calendar."
+  ).optional()
+}).strict();
+var outputSchema29 = eventSchema;
+var definition29 = defineTool29({
+  name: "updateEvent",
+  title: "Update Event",
+  description: "Update a calendar event \u2014 change subject, time, location, body, attendees, or categories. Set only the fields you want to change. The attendees array REPLACES the existing list, so read the current attendees via getEvent, append, then update.",
+  inputSchema: inputSchema29,
+  outputSchema: outputSchema29,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const { eventId, mailbox, calendarId, ...patch } = input;
+    const url = `${GRAPH_BASE}${calendarRoot(mailbox, calendarId)}/events/${encodeURIComponent(
+      eventId
+    )}`;
+    const res = await outlookFetch(ctx.fetch, "updateEvent", url, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+    return parseGraphResponse(res);
+  }
+});
+var updateEvent_default = definition29;
+await handleIfScriptMain29(import.meta, definition29, { connectionResolvers });
+
+// scripts/updateMessage.ts
+import { defineTool as defineTool30, handleIfScriptMain as handleIfScriptMain30 } from "@zapier/connectors-sdk";
+import { z as z31 } from "zod";
+var inputSchema30 = z31.object({
+  messageId: z31.string().describe(
+    "Message id from listMessages or another message tool. Opaque and case-sensitive; changes when the message is moved between folders."
+  ),
+  isRead: z31.boolean().describe("Mark the message read (true) or unread (false).").optional(),
+  importance: z31.enum(["low", "normal", "high"]).describe("Importance level.").optional(),
+  categories: z31.array(z31.string()).describe(
+    "Category names to assign. REPLACES the existing set \u2014 read the current categories via getMessage and include them if you want to append rather than overwrite."
+  ).optional(),
+  flag: z31.strictObject({
+    flagStatus: z31.enum(["notFlagged", "flagged", "complete"]).describe("Follow-up flag state."),
+    startDateTime: dateTimeTimeZoneInputSchema.optional(),
+    dueDateTime: dateTimeTimeZoneInputSchema.optional()
+  }).describe("Follow-up flag to set on the message.").optional(),
+  mailbox: z31.string().describe(
+    "Shared-mailbox address (UPN/email) to update instead of your own. Requires shared-mailbox delegation. Omit for your own mailbox."
+  ).optional()
+}).strict();
+var outputSchema30 = z31.object({
+  id: z31.string(),
+  subject: z31.string(),
+  isRead: z31.boolean(),
+  importance: z31.string().optional(),
+  categories: z31.array(z31.string()).optional(),
+  flag: followupFlagSchema.optional()
+});
+var definition30 = defineTool30({
+  name: "updateMessage",
+  title: "Update Message",
+  description: "Update a message's state \u2014 mark read/unread, change importance, replace its categories, or set a follow-up flag. Set only the fields you want to change; everything else is left untouched. Resolve the message id via listMessages first. Subject/body are editable only on drafts.",
+  inputSchema: inputSchema30,
+  outputSchema: outputSchema30,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "microsoft-outlook",
+  run: async (input, ctx) => {
+    const url = `${GRAPH_BASE}${mailboxRoot(input.mailbox)}/messages/${encodeURIComponent(
+      input.messageId
+    )}`;
+    const body = {};
+    if (input.isRead !== void 0) body.isRead = input.isRead;
+    if (input.importance !== void 0) body.importance = input.importance;
+    if (input.categories !== void 0) body.categories = input.categories;
+    if (input.flag !== void 0) body.flag = input.flag;
+    const res = await outlookFetch(ctx.fetch, "updateMessage", url, {
+      method: "PATCH",
+      body: JSON.stringify(body)
+    });
+    return parseGraphResponse(res);
+  }
+});
+var updateMessage_default = definition30;
+await handleIfScriptMain30(import.meta, definition30, { connectionResolvers });
+
+// index.ts
+var connector = defineConnector({
+  scripts: {
+    copyMessage: copyMessage_default,
+    createContact: createContact_default,
+    createDraft: createDraft_default,
+    createEvent: createEvent_default,
+    createMailFolder: createMailFolder_default,
+    createReplyDraft: createReplyDraft_default,
+    deleteContact: deleteContact_default,
+    deleteEvent: deleteEvent_default,
+    deleteMessage: deleteMessage_default,
+    forwardMessage: forwardMessage_default,
+    getAttachment: getAttachment_default,
+    getContact: getContact_default,
+    getEvent: getEvent_default,
+    getMe: getMe_default,
+    getMessage: getMessage_default,
+    listAttachments: listAttachments_default,
+    listCalendars: listCalendars_default,
+    listCalendarView: listCalendarView_default,
+    listCategories: listCategories_default,
+    listContacts: listContacts_default,
+    listEvents: listEvents_default,
+    listMailFolders: listMailFolders_default,
+    listMessages: listMessages_default,
+    moveMessage: moveMessage_default,
+    replyToMessage: replyToMessage_default,
+    sendDraft: sendDraft_default,
+    sendMail: sendMail_default,
+    updateContact: updateContact_default,
+    updateEvent: updateEvent_default,
+    updateMessage: updateMessage_default
+  },
+  connectionResolvers
+});
+var index_default = connector;
+var {
+  copyMessage,
+  createContact,
+  createDraft,
+  createEvent,
+  createMailFolder,
+  createReplyDraft,
+  deleteContact,
+  deleteEvent,
+  deleteMessage,
+  forwardMessage,
+  getAttachment,
+  getContact,
+  getEvent,
+  getMe,
+  getMessage,
+  listAttachments,
+  listCalendars,
+  listCalendarView,
+  listCategories,
+  listContacts,
+  listEvents,
+  listMailFolders,
+  listMessages,
+  moveMessage,
+  replyToMessage,
+  sendDraft,
+  sendMail,
+  updateContact,
+  updateEvent,
+  updateMessage
+} = toFunctions(connector);
+export {
+  copyMessage,
+  createContact,
+  createDraft,
+  createEvent,
+  createMailFolder,
+  createReplyDraft,
+  index_default as default,
+  deleteContact,
+  deleteEvent,
+  deleteMessage,
+  forwardMessage,
+  getAttachment,
+  getContact,
+  getEvent,
+  getMe,
+  getMessage,
+  listAttachments,
+  listCalendarView,
+  listCalendars,
+  listCategories,
+  listContacts,
+  listEvents,
+  listMailFolders,
+  listMessages,
+  moveMessage,
+  replyToMessage,
+  sendDraft,
+  sendMail,
+  updateContact,
+  updateEvent,
+  updateMessage
+};