@deploybaseline/microsoft 0.0.0-stage → 0.14.1

package/dist/chunk-BEGIZZSN.js

@@ -0,0 +1,4762 @@
+// src/graph/handlers/upload.ts
+import { randomBytes as randomBytes4, randomUUID as randomUUID3 } from "crypto";
+
+// src/graph/errors.ts
+var GraphError = class extends Error {
+  status;
+  code;
+  layer;
+  headers;
+  /** innerError.code (To Do service errors carry one). */
+  innerCode;
+  /** Extra members of the error object (annotations such as `@error.fixItUrl`). */
+  extra;
+  constructor(status, code, message, layer = "exchange", headers = {}, innerCode, extra = {}, options) {
+    super(message, options);
+    this.status = status;
+    this.code = code;
+    this.layer = layer;
+    this.headers = headers;
+    this.innerCode = innerCode;
+    this.extra = extra;
+  }
+};
+var TodoErrors = {
+  /** Unsupported query option ($select on collections and lists, $orderby, $select on delta). */
+  parseUri: () => new GraphError(400, "invalidRequest", "Invalid request", "todo", {}, "RequestBroker--ParseUri"),
+  /** Body that does not bind to the model (for example an unknown enum value). */
+  invalidModel: () => new GraphError(400, "invalidRequest", "Invalid request", "todo", {}, "InvalidModel"),
+  notFound: () => new GraphError(404, "ErrorItemNotFound", "Item not found", "todo", {}, "ErrorItemNotFound"),
+  /** Verified live (todo.dates-and-defaults): PATCH displayName of the default list. */
+  defaultListRename: () => new GraphError(400, "invalidRequest", "Invalid request", "todo", {}, "ErrorInvalidRequest"),
+  /** Verified live (todo.dates-and-defaults): DELETE of the default list. */
+  defaultListDelete: () => new GraphError(
+    400,
+    "invalidRequest",
+    "The default Tasks folder can not be deleted",
+    "todo",
+    {},
+    "CantDeleteDefaultFolder"
+  ),
+  /** Verified live (todo.flagged-emails): DELETE of the Flagged Emails list. */
+  flaggedListDelete: () => new GraphError(
+    400,
+    "invalidRequest",
+    "The Flagged Emails folder can not be deleted",
+    "todo",
+    {},
+    "InvalidTaskFolderOperation"
+  )
+};
+var g = (status, code, message, headers, options) => new GraphError(status, code, message, "graph", headers, void 0, void 0, options);
+var x = (status, code, message, options) => new GraphError(status, code, message, "exchange", void 0, void 0, void 0, options);
+var Errors = {
+  /** Verified live (calendar.boundaries). */
+  allDayTooShort: () => x(
+    400,
+    "ErrorInvalidRequest",
+    "Your request can't be completed. The duration of an event marked as All day must be at least 24 hours."
+  ),
+  /** Verified live (contacts.boundaries). */
+  tooManyContactEmails: (n) => x(
+    400,
+    "ErrorInvalidProperty",
+    `The multi value property emailAddresses has ${n} entries, that exceeds the max allowed value of 3.`
+  ),
+  /** Verified live (contacts.boundaries): a graph-layer envelope. */
+  contactPhotoNotFound: () => g(404, "ErrorItemNotFound", "The specified object was not found in the store."),
+  /** Verified live for Start (calendar.allday-order-paging); End assumed to match. */
+  allDayNotMidnight: (which) => x(
+    400,
+    "ErrorInvalidRequest",
+    `Your request can't be completed. The Event.${which} property for an all-day event needs to be set to midnight.`
+  ),
+  /** Verified live (places.rooms): an unknown place id or address. */
+  placeNotFound: (id) => g(404, "notFound", `Place with identity ${id} is not found`),
+  /** Verified live (permissions.write-places-and-translate): PATCH with Place.Read.All only. */
+  placesWriteForbidden: () => g(
+    403,
+    "forbidden",
+    "Insufficient privileges to complete the operation. The signed-in user must be assigned a supported Microsoft Entra role. Exchange Administrator is the least privileged role supported for this operation."
+  ),
+  defaultCalendarDelete: () => x(400, "ErrorInvalidRequest", "Your request can't be completed. The default calendar cannot be deleted."),
+  // ---- authentication (front end) ----
+  tokenEmpty: () => g(401, "InvalidAuthenticationToken", "Access token is empty.", wwwAuthenticate()),
+  tokenUnreadable: (options) => g(
+    401,
+    "InvalidAuthenticationToken",
+    "Protocol 'Bearer' failed to validate because The token could not be read.",
+    wwwAuthenticate(),
+    options
+  ),
+  tokenNoAppId: () => g(401, "InvalidAuthenticationToken", "NoAppIdInToken", wwwAuthenticate()),
+  tokenExpired: () => g(401, "InvalidAuthenticationToken", "Lifetime validation failed, the token is expired.", wwwAuthenticate()),
+  tokenSignature: () => g(401, "InvalidAuthenticationToken", "Signature validation failed.", wwwAuthenticate()),
+  /** Observed on Graph (docs/research/behavior-research.md, InvalidAuthenticationToken). */
+  tokenAudience: () => g(401, "InvalidAuthenticationToken", "Access token validation failure. Invalid audience.", wwwAuthenticate()),
+  /** A token this emulator signed that was revoked since (the revoke endpoint is an emulator extension). */
+  tokenInvalid: () => g(401, "InvalidAuthenticationToken", "Access token validation failure.", wwwAuthenticate()),
+  meRequiresDelegated: () => g(400, "BadRequest", "/me request is only valid with delegated authentication flow."),
+  directoryDenied: () => g(403, "Authorization_RequestDenied", "Insufficient privileges to complete the operation."),
+  directoryMethodNotAllowed: () => g(405, "Request_BadRequest", "Specified HTTP method is not allowed for the request target."),
+  // ---- routing / OData (front end) ----
+  invalidVersion: (v) => g(404, "ResourceNotFound", `Invalid version: ${v}`),
+  directoryResourceNotFound: (segment) => g(
+    404,
+    "Request_ResourceNotFound",
+    `Resource '${segment}' does not exist or one of its queried reference-property objects are not present.`
+  ),
+  segmentNotFound: (segment) => g(400, "BadRequest", `Resource not found for the segment '${segment}'.`),
+  noContentType: () => g(400, "BadRequest", "Write requests (excluding DELETE) must contain the Content-Type header declaration."),
+  unreadableJson: () => g(
+    400,
+    "BadRequest",
+    "Unable to read JSON request payload. Please ensure Content-Type header is set and payload is of valid JSON format."
+  ),
+  selectExpandParse: (prop, type) => g(
+    400,
+    "BadRequest",
+    `Parsing OData Select and Expand failed: Could not find a property named '${prop}' on type 'microsoft.graph.${type}'.`
+  ),
+  invalidTop: (v) => g(
+    400,
+    "BadRequest",
+    `Invalid value '${v}' for $top query option found. The $top query option requires a non-negative integer value.`
+  ),
+  invalidSkip: (v) => g(
+    400,
+    "BadRequest",
+    `Invalid value '${v}' for $skip query option found. The $skip query option requires a non-negative integer value.`
+  ),
+  filterClause: (detail) => g(400, "BadRequest", `Invalid filter clause: ${detail}`),
+  orderbyClause: (detail) => g(400, "BadRequest", `Invalid orderby clause: ${detail}`),
+  badDeltaToken: () => g(400, "BadRequest", "Badly formed token."),
+  changeTrackingUnsupported: (type) => g(400, "BadRequest", `Unsupported request: Change tracking is not supported against 'microsoft.graph.${type}'.`),
+  batchLimit: () => g(400, "BadRequest", "Number of requests inside batch exceed the limit."),
+  batchDuplicateId: (id) => g(400, "BadRequest", `Request Id ${id} has to be unique in a batch.`),
+  batchMissingContentType: (id) => g(400, "BadRequest", `Write request with id '${id}' does not contain a Content-Type header.`),
+  batchInvalid: (options) => g(400, "BadRequest", "Invalid batch payload format.", void 0, options),
+  batchFailedDependency: () => g(424, "FailedDependency", "Request failed as dependent request failed"),
+  methodNotAllowed: () => x(405, "ErrorInvalidRequest", "The OData request is not supported."),
+  unsupportedRequest: (detail) => g(400, "BadRequest", `Unsupported request: ${detail}`),
+  // ---- Outlook REST query layer ----
+  parseUriProperty: (prop, type = "microsoft.graph.message", withInner = false) => withInner ? g(400, "RequestBroker--ParseUri", `Could not find a property named '${prop}' on type '${type}'.`) : x(400, "RequestBroker--ParseUri", `Could not find a property named '${prop}' on type '${type}'.`),
+  inefficientFilter: () => x(400, "InefficientFilter", "The restriction or sort order is too complex for this operation."),
+  invalidFilterNodes: () => x(400, "ErrorInvalidUrlQueryFilter", "The query filter contains one or more invalid nodes."),
+  deltaFilterUnsupported: () => x(
+    400,
+    "ErrorInvalidUrlQuery",
+    "The '$filter' parameter value is not supported for 'Messages' resource; only a value of 'receivedDateTime ge value' is supported."
+  ),
+  searchWithFilter: () => x(400, "SearchWithFilter", "The query parameter '$filter' is not supported with '$search'."),
+  searchWithOrderBy: () => x(400, "SearchWithOrderBy", "The query parameter '$orderBy' is not supported with '$search'."),
+  unsupportedSortPath: () => x(400, "ErrorUnsupportedPathForSortGroup", "The property can not be used for sorting or grouping results."),
+  searchWithSkip: () => x(400, "SearchWithSkip", "The query parameter '$skip' is not supported with '$search'."),
+  // ---- store ----
+  idMalformed: () => x(400, "ErrorInvalidIdMalformed", "Id is malformed."),
+  itemNotFound: () => x(
+    404,
+    "ErrorItemNotFound",
+    "The specified object was not found in the store., The process failed to get the correct properties."
+  ),
+  attachmentNotFound: () => x(404, "ErrorItemNotFound", "The specified object was not found in the store."),
+  /**
+   * Verified live (delegated.access-and-zones): a delegated caller with
+   * .Shared scopes but no access to another user's mailbox gets 404, not 403.
+   * Under a well-known folder the message names the folder.
+   */
+  mailboxNotAccessible: (defaultFolder) => x(
+    404,
+    "ErrorItemNotFound",
+    defaultFolder ? `The specified object was not found in the store., Default folder ${defaultFolder} not found.` : "The specified object was not found in the store."
+  ),
+  folderNotFound: () => x(404, "ErrorFolderNotFound", "The specified folder could not be found in the store."),
+  wrongMailbox: (id, mailboxGuid) => x(404, "ErrorInvalidMailboxItemId", `Item '${id}' doesn't belong to the targeted mailbox '${mailboxGuid}'.`),
+  folderIdForItemId: () => x(400, "ErrorCannotUseFolderIdForItemId", "Expected an item Id but received a folder Id."),
+  itemIdForFolderId: () => x(400, "ErrorCannotUseItemIdForFolderId", "Expected a folder Id but received an item Id."),
+  invalidUser: (who) => x(404, "ErrorInvalidUser", `The requested user '${who}' is invalid.`),
+  mailboxNotEnabled: () => x(404, "MailboxNotEnabledForRESTAPI", "The mailbox is either inactive, soft-deleted, or is hosted on-premise."),
+  accessDenied: (options) => x(403, "ErrorAccessDenied", "Access is denied. Check credentials and try again.", options),
+  cannotResubmit: () => x(403, "ErrorAccessDenied", "Access is denied. Check credentials and try again., Cannot submit message."),
+  sendAsDenied: () => x(
+    403,
+    "ErrorSendAsDenied",
+    "The user account which was used to submit this request does not have the right to send mail on behalf of the specified sending account., Cannot submit message."
+  ),
+  applicationAccessPolicy: () => x(
+    403,
+    "ErrorAccessDenied",
+    "Access to OData is disabled: [RAOP] : Blocked by tenant configured AppOnly AccessPolicy settings."
+  ),
+  invalidReferenceItem: () => x(400, "ErrorInvalidReferenceItem", "The reference item does not support the requested operation."),
+  invalidChangeKey: () => x(400, "ErrorInvalidChangeKey", "The change key is invalid."),
+  bodyContentTypeNotSupported: () => x(
+    400,
+    "ErrorBodyContentTypeNotSupported",
+    "The body content type in the body-content-type preferred header is not supported."
+  ),
+  attachmentTooSmall: () => x(400, "ErrorAttachmentSizeShouldBeGreaterThanZero", "Attachment size must be greater than the minimum size."),
+  attachmentTooLarge: () => x(
+    400,
+    "ErrorAttachmentSizeShouldNotBeMoreThanMaximumSize",
+    "Attachment size must be greater than the minimum size."
+  ),
+  requestEntityTooLarge: () => x(413, "ErrorRequestEntityTooLarge", "The request entity is too large."),
+  throttled: (retryAfter) => new GraphError(429, "ApplicationThrottled", "Application is over its MailboxConcurrency limit.", "exchange", {
+    "Retry-After": String(retryAfter)
+  }),
+  // ---- folders ----
+  folderExists: (name) => x(409, "ErrorFolderExists", `A folder with the specified name already exists., Could not create folder '${name}'.`),
+  folderSaveProperty: () => x(400, "ErrorFolderSavePropertyError", "The folder save operation failed due to invalid property values."),
+  deleteDistinguished: () => x(400, "ErrorDeleteDistinguishedFolder", "Distinguished folders cannot be deleted."),
+  moveCopyFailed: () => x(500, "ErrorMoveCopyFailed", "The move or copy operation failed."),
+  // ---- payload ----
+  requiredProperty: (prop) => x(400, "ErrorInvalidProperty", `The property '${prop}' is required when creating the entity.`),
+  missingParameters: (op, params) => x(
+    400,
+    "RequestBodyRead",
+    `One or more parameters of the operation '${op}' are missing from the request payload. The missing parameters are: ${params.join(", ")}.`
+  ),
+  unknownBodyProperty: (prop, type) => x(
+    400,
+    "RequestBodyRead",
+    `The property '${prop}' does not exist on type 'microsoft.graph.${type}'. Make sure to only use property names that are defined by the type or mark the type as open type.`
+  ),
+  enumValueNotFound: (value) => x(400, "RequestBodyRead", `Requested value '${value}' was not found.`),
+  literalConversion: (literal2, type) => x(400, "RequestBodyRead", `Cannot convert the literal '${literal2}' to the expected type '${type}'.`),
+  unableToDeserialize: () => x(400, "UnableToDeserializePostBody", "were unable to deserialize "),
+  internalServerError: () => x(500, "ErrorInternalServerError", "An internal server error occurred. The operation failed."),
+  internalServerErrorDetail: (detail) => x(500, "ErrorInternalServerError", `An internal server error occurred. The operation failed., ${detail}`),
+  invalidSourceFolderIds: () => x(400, "ErrorInvalidSourceFolderIds", "Source Folder Ids cannot be empty."),
+  filterQueryParse: (detail) => x(400, "ErrorParsingFilterQuery-ParseUri", detail),
+  extensionExpandRequiresFilter: () => x(
+    400,
+    "ErrorGraphExtensionExpandRequiresFilter",
+    "When expanding extensions, a filter must be provided to specify which extensions to expand. For example $expand=Extensions($filter=Id eq 'Com.Insightly.CRMOpportunity')."
+  ),
+  abstractType: (type) => x(422, "UnprocessableType", `Cannot process input of abstract type 'microsoft.graph.${type}'`),
+  parameterEmpty: (name) => x(400, "ErrorInvalidParameter", `The value of the parameter '${name}' is empty.`),
+  // ---- send ----
+  noRecipients: () => x(
+    400,
+    "ErrorInvalidRecipients",
+    "At least one recipient is not valid., A message can't be sent because it contains no recipients."
+  ),
+  unresolvedRecipient: (addr) => x(
+    400,
+    "ErrorInvalidRecipients",
+    `At least one recipient is not valid., Recipient '${addr}' is not resolved. All recipients must be resolved before a message can be submitted.`
+  ),
+  missingRecipients: () => x(400, "ErrorMissingRecipients", "A message needs to have at least one recipient."),
+  forwardRecipientsEmpty: () => x(
+    400,
+    "ErrorParameterValueEmpty",
+    "The value of the parameter 'ToRecipients' is empty. Specify 'ToRecipients' either in the message object or in the action."
+  ),
+  irresolvableConflict: () => x(
+    412,
+    "ErrorIrresolvableConflict",
+    "The send or update operation could not be performed because the change key passed in the request does not match the current change key for the item."
+  ),
+  // ---- MIME ----
+  mimeInvalidBase64: () => x(400, "ErrorMimeContentInvalidBase64String", "Invalid base64 string for MIME content."),
+  mimeConversionFailed: () => x(400, "ErrorMimeContentConversionFailed", "The MIME content could not be converted."),
+  // ---- upload sessions (Outlook host) ----
+  uploadInvalidStart: () => x(400, "InvalidStart", "Invalid Start offset for the current fragment. Fragment might already have been uploaded."),
+  uploadInvalidRange: () => x(400, "InvalidContentRange", "The Content-Range header is missing or malformed."),
+  // ---- calendar (sources in docs/research/calendar-contacts.md; none verified live) ----
+  /** Observed in several SDK issues (3.1). */
+  timeWindowRequired: () => x(
+    400,
+    "ErrorInvalidParameter",
+    "This request requires a time window specified by the query string parameters StartDateTime and EndDateTime."
+  ),
+  /** Observed code (2); message text assumed. */
+  timeZoneNotSupported: (name) => x(
+    400,
+    "TimeZoneNotSupportedException",
+    `A valid TimeZone value must be specified. The following TimeZone value is not supported: '${name}'.`
+  ),
+  /** EWS code and message (observed through EWS); Graph surface assumed. */
+  endBeforeStart: () => x(400, "ErrorCalendarEndDateIsEarlierThanStartDate", "EndDate is earlier than StartDate"),
+  /** Code observed (outlook-mcp); message assumed. */
+  propertyValidation: () => x(400, "ErrorPropertyValidationFailure", "At least one property failed validation."),
+  invalidRecurrenceRange: () => x(400, "ErrorInvalidRecurrenceRange", "The recurrence range is invalid."),
+  /** Observed (outlook-mcp issue #86). */
+  recurrenceEndBeforeStart: () => x(400, "ErrorInvalidParameter", "StartDateV2 should be earlier or equal to EndDateV2"),
+  /** Documented on event-update. */
+  occurrenceCrossingBoundary: () => x(400, "ErrorOccurrenceCrossingBoundary", "Modified occurrence is crossing or overlapping adjacent occurrence."),
+  /** Documented message on event-cancel; code assumed. */
+  organizerOnlyCancel: () => x(400, "ErrorInvalidRequest", "Your request can't be completed. You need to be an organizer to cancel a meeting."),
+  /** Verified live for accept; decline and tentativelyAccept assumed to match. */
+  organizerCannotRespond: (_action) => x(
+    400,
+    "ErrorInvalidRequest",
+    "Your request can't be completed. You can't respond to this meeting because you're the meeting organizer."
+  ),
+  /** Observed in a Q&A thread for contacts; reused for default calendars (assumed). */
+  cannotDeleteObject: () => x(400, "ErrorCannotDeleteObject", "Object cannot be deleted."),
+  /** Documented that proposals fail with 400; code and message assumed. */
+  proposalsNotAllowed: () => x(
+    400,
+    "ErrorInvalidRequest",
+    "Your request can't be completed. New time proposals are not allowed for this meeting."
+  ),
+  /** Observed (outlook-mcp CHANGELOG). */
+  missingEventStart: () => x(400, "ErrorInvalidRequest", "Missing parameters: Event.Start"),
+  /** Documented: findMeetingTimes has no application permission. */
+  delegatedOnly: () => g(401, "UnknownError", ""),
+  /** Verified live (workspace.permissions.mail-only-app): places and To Do without permission. */
+  unknownAuthError: () => g(401, "UnknownError", ""),
+  // Assumed codes for calendar sharing validation (not observed).
+  invalidDelegateRole: () => x(400, "ErrorInvalidParameter", "Delegate roles can only be granted on the primary calendar."),
+  /** Verified live: a delegate role on a secondary calendar. */
+  sharingRoleNotSupported: (role, address) => x(
+    400,
+    "ErrorInvalidRequest",
+    `Your request can't be completed. Sharing with permission level '${role.charAt(0).toUpperCase()}${role.slice(1)}' is not supported for this calendar for user '${address}'.`
+  ),
+  /** Verified live: PATCH of a calendarPermission without role. */
+  permissionLevelRequired: () => x(
+    400,
+    "ErrorInvalidRequest",
+    "Your request can't be completed. Permission level needs to be specified when sharing calendar."
+  ),
+  /** Verified live: a sharee listing the owner's calendarPermissions. */
+  notSupported: () => x(400, "ErrorNotSupported", "Specified method is not supported."),
+  // ---- generic ----
+  notImplemented: (what) => g(501, "NotImplemented", `The emulator does not implement ${what}.`),
+  internal: (detail) => g(500, "InternalServerError", detail)
+};
+function wwwAuthenticate() {
+  return {
+    "WWW-Authenticate": 'Bearer realm="", authorization_uri="https://login.microsoftonline.com/common/oauth2/authorize", client_id="00000003-0000-0000-c000-000000000000"'
+  };
+}
+function renderError(err, ctx) {
+  if (err.layer === "sharepoint") {
+    const error2 = {
+      code: err.code,
+      ...err.innerCode ? { innerError: { code: err.innerCode } } : {},
+      message: err.message,
+      ...err.extra
+    };
+    return { status: err.status, body: { error: error2 }, headers: err.headers };
+  }
+  const error = { code: err.code, message: err.message, ...err.extra };
+  if (err.layer === "graph" || err.layer === "todo") {
+    const date = (ctx.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 19);
+    error.innerError = {
+      ...err.innerCode ? { code: err.innerCode } : {},
+      date,
+      "request-id": ctx.requestId,
+      "client-request-id": ctx.clientRequestId
+    };
+  }
+  return { status: err.status, body: { error }, headers: err.headers };
+}
+
+// src/graph/exchange/calendar.ts
+import { randomBytes as randomBytes3 } from "crypto";
+
+// src/graph/exchange/ids.ts
+import { randomBytes } from "crypto";
+var TRAILING_PADDING = /[=]+$/;
+var URL_SAFE_PADDING_COUNT = /^([A-Za-z0-9\-_]*)([012])$/;
+var BASE64_ANY_ALPHABET = /^[A-Za-z0-9\-_+/]+={0,2}$/;
+var GUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function exchangeBase64(buf) {
+  return buf.toString("base64").replace(/\//g, "-").replace(/\+/g, "_");
+}
+function fromExchangeBase64(s) {
+  if (!BASE64_ANY_ALPHABET.test(s)) {
+    return null;
+  }
+  const std = s.replace(/-/g, "/").replace(/_/g, "+");
+  if (std.replace(TRAILING_PADDING, "").length % 4 === 1) {
+    return null;
+  }
+  return Buffer.from(std, "base64");
+}
+function newStoreIdentity(mailboxGuid) {
+  return {
+    mailboxGuid,
+    providerUid: randomBytes(16).toString("hex"),
+    databaseGuid: randomBytes(16).toString("hex")
+  };
+}
+function gc(counter) {
+  const b = Buffer.alloc(6);
+  b.writeUIntBE(counter, 0, 6);
+  return b;
+}
+function header(store, entryLen) {
+  return Buffer.concat([
+    Buffer.from([store.standardIds ? 0 : 1, 3, 36, 0]),
+    Buffer.from(store.mailboxGuid, "ascii"),
+    Buffer.from([0, entryLen, 0])
+  ]);
+}
+function flags(store) {
+  return store.standardIds ? Buffer.from([0, 0, 0, 0]) : Buffer.from([0, 3]);
+}
+function encodeFolderId(store, folderCounter) {
+  const entry = Buffer.concat([
+    flags(store),
+    Buffer.from(store.providerUid, "hex"),
+    Buffer.from([1, 0]),
+    Buffer.from(store.databaseGuid, "hex"),
+    gc(folderCounter),
+    Buffer.from([0, 0])
+  ]);
+  return exchangeBase64(Buffer.concat([header(store, 46), entry]));
+}
+function encodeItemId(store, folderCounter, itemCounter) {
+  const entry = Buffer.concat([
+    flags(store),
+    Buffer.from(store.providerUid, "hex"),
+    Buffer.from([7, 0]),
+    Buffer.from(store.databaseGuid, "hex"),
+    gc(folderCounter),
+    Buffer.from([0, 0]),
+    Buffer.from(store.databaseGuid, "hex"),
+    gc(itemCounter),
+    Buffer.from([0, 0])
+  ]);
+  return exchangeBase64(Buffer.concat([header(store, 70), entry]));
+}
+function encodeConversationId(mailboxGuid, conversationGuid) {
+  return exchangeBase64(
+    Buffer.concat([
+      Buffer.from([0, 4, 36, 0]),
+      Buffer.from(mailboxGuid, "ascii"),
+      Buffer.from([0, 16, 0]),
+      conversationGuid
+    ])
+  );
+}
+var IMMUTABLE_PREFIX = Buffer.from("0009002e00000000001d840311aa6611cd9bc800aa002fc45a", "hex");
+function immutableEntryIdBytes(restImmutable) {
+  return Buffer.concat([Buffer.alloc(4), IMMUTABLE_PREFIX.subarray(9), restImmutable.subarray(25)]);
+}
+function restImmutableFromEntryId(bin) {
+  if (bin.length !== 46 || bin.readUInt32BE(0) !== 0) {
+    return null;
+  }
+  if (!bin.subarray(4, 20).equals(IMMUTABLE_PREFIX.subarray(9)) || bin[20] !== 13) {
+    return null;
+  }
+  return Buffer.concat([IMMUTABLE_PREFIX, bin.subarray(20)]);
+}
+function foreignEntryIdToRest(store, bin) {
+  if (bin.length !== 46 && bin.length !== 70 || bin.readUInt32BE(0) !== 0) {
+    return null;
+  }
+  if (bin[20] !== (bin.length === 46 ? 1 : 7)) {
+    return null;
+  }
+  return exchangeBase64(Buffer.concat([header(store, bin.length === 46 ? 46 : 70), flags(store), bin.subarray(4)]));
+}
+function encodeImmutableId(store, immutableCounter) {
+  return exchangeBase64(
+    Buffer.concat([
+      IMMUTABLE_PREFIX,
+      Buffer.from([13, 0]),
+      Buffer.from(store.databaseGuid, "hex"),
+      gc(immutableCounter),
+      Buffer.from([0, 0])
+    ])
+  );
+}
+function dotnetTicks(ms) {
+  return (BigInt(ms) + 62135596800000n) * 10000n;
+}
+function fromDotnetTicks(ticks) {
+  return Number(ticks / 10000n - 62135596800000n);
+}
+function encodeOccurrenceId(store, folderCounter, masterCounter, dateMs) {
+  const master = fromExchangeBase64(encodeItemId(store, folderCounter, masterCounter));
+  const ticks = Buffer.alloc(8);
+  ticks.writeBigUInt64BE(dotnetTicks(dateMs));
+  return exchangeBase64(
+    Buffer.concat([
+      master.subarray(0, 40),
+      Buffer.from([1, 81, 0, 8]),
+      ticks,
+      master.subarray(40),
+      Buffer.from([0, 16])
+    ])
+  );
+}
+function decodeId(id) {
+  const buf = fromExchangeBase64(id);
+  if (!buf) {
+    return null;
+  }
+  if (buf.length === 51 && buf.subarray(0, 25).equals(IMMUTABLE_PREFIX) && buf[25] === 13) {
+    return {
+      kind: "immutable",
+      databaseGuid: buf.subarray(27, 43).toString("hex"),
+      immutableCounter: buf.readUIntBE(43, 6)
+    };
+  }
+  if (buf.length < 44) {
+    return null;
+  }
+  if (buf[0] !== 1 && buf[0] !== 0 || buf[1] !== 3 || buf[2] !== 36) {
+    return null;
+  }
+  if (buf[40] === 1 && buf[41] === 81 && buf[42] === 0 && buf[43] === 8 && buf.length > 54) {
+    const ticks = buf.readBigUInt64BE(44);
+    const inner = Buffer.concat([buf.subarray(0, 40), buf.subarray(52, buf.length - 2)]);
+    const master = decodeId(exchangeBase64(inner));
+    if (master?.kind !== "item") {
+      return null;
+    }
+    return { ...master, kind: "occurrence", dateMs: fromDotnetTicks(ticks) };
+  }
+  const mailboxGuid = buf.subarray(4, 40).toString("ascii");
+  if (!GUID_FORMAT.test(mailboxGuid)) {
+    return null;
+  }
+  const { 41: len } = buf;
+  const o = buf[0] === 1 ? 43 + 2 : 43 + 4;
+  const extra = o - 45;
+  if (buf.length === 87 + extra && len === 46) {
+    return {
+      kind: "folder",
+      mailboxGuid,
+      databaseGuid: buf.subarray(o + 18, o + 34).toString("hex"),
+      folderCounter: buf.readUIntBE(o + 34, 6)
+    };
+  }
+  if (buf.length === 111 + extra && len === 70) {
+    const folderCounter = buf.readUIntBE(o + 34, 6);
+    const itemCounter = buf.readUIntBE(o + 34 + 8 + 16, 6);
+    return {
+      kind: "item",
+      mailboxGuid,
+      databaseGuid: buf.subarray(o + 18, o + 34).toString("hex"),
+      folderCounter,
+      itemCounter
+    };
+  }
+  return null;
+}
+function changeKeyClass(kind) {
+  if (kind === "folder") {
+    return 1;
+  }
+  if (kind === "eventLong") {
+    return 15;
+  }
+  return kind === "contact" ? 17 : 9;
+}
+function encodeChangeKey(store, changeNumber, kind = "item") {
+  if (kind === "event") {
+    const s = Buffer.alloc(22);
+    Buffer.from(store.databaseGuid, "hex").copy(s, 0);
+    s.writeUIntBE(changeNumber, 16, 6);
+    return s.toString("base64");
+  }
+  const cls = changeKeyClass(kind);
+  const b = Buffer.alloc(30);
+  b.writeUInt32LE(cls, 0);
+  b.writeUInt32LE(22, 4);
+  Buffer.from(store.databaseGuid, "hex").copy(b, 8);
+  b.writeUIntBE(changeNumber, 24, 6);
+  return b.toString("base64");
+}
+function newConversationIndex(at, guid) {
+  const filetime = BigInt(at.getTime()) * 10000n + 116444736000000000n;
+  const indexHeader = Buffer.alloc(6);
+  indexHeader[0] = 1;
+  const top = filetime >> 16n;
+  for (let i = 0; i < 5; i += 1) {
+    indexHeader[1 + i] = Number(top >> BigInt(8 * (5 - i)) & 0xffn);
+  }
+  return Buffer.concat([indexHeader, guid]);
+}
+function childConversationIndex(parent, at, parentAt) {
+  const deltaTicks = BigInt(Math.max(0, at.getTime() - parentAt.getTime())) * 10000n;
+  const delta = Number(deltaTicks >> 18n & 0x7fffffffn);
+  const block = Buffer.alloc(5);
+  block.writeUInt32BE(delta >>> 0, 0);
+  block[4] = randomBytes(1)[0];
+  return Buffer.concat([parent, block]);
+}
+function newInternetMessageId() {
+  const server = `EMUP287MB${String(1e3 + randomBytes(2).readUInt16BE(0) % 9e3)}`;
+  return `<${server}${randomBytes(12).toString("hex").toUpperCase().slice(0, 21)}@${server}.EMUP287.PROD.OUTLOOK.COM>`;
+}
+function urlSafeBinary(buf) {
+  const b64 = buf.toString("base64");
+  const pad = b64.length - b64.replace(TRAILING_PADDING, "").length;
+  return `${b64.replace(TRAILING_PADDING, "").replace(/\+/g, "-").replace(/\//g, "_")}${pad}`;
+}
+function fromUrlSafeBinary(s) {
+  const m = URL_SAFE_PADDING_COUNT.exec(s);
+  if (!m) {
+    return null;
+  }
+  return Buffer.from(m[1].replace(/-/g, "+").replace(/_/g, "/") + "=".repeat(Number(m[2])), "base64");
+}
+function entryIdBytes(store, folderCounter, itemCounter) {
+  const parts = [
+    Buffer.from([0, 0, 0, 0]),
+    Buffer.from(store.providerUid, "hex"),
+    Buffer.from([itemCounter === null ? 1 : 7, 0]),
+    Buffer.from(store.databaseGuid, "hex"),
+    gc(folderCounter),
+    Buffer.from([0, 0])
+  ];
+  if (itemCounter !== null) {
+    parts.push(Buffer.from(store.databaseGuid, "hex"), gc(itemCounter), Buffer.from([0, 0]));
+  }
+  return Buffer.concat(parts);
+}
+function parseEntryId(buf, store) {
+  if (buf.length !== 46 && buf.length !== 70) {
+    return null;
+  }
+  if (buf.readUInt32BE(0) !== 0) {
+    return null;
+  }
+  if (buf.subarray(4, 20).toString("hex") !== store.providerUid) {
+    return null;
+  }
+  if (buf.subarray(22, 38).toString("hex") !== store.databaseGuid) {
+    return null;
+  }
+  const folderCounter = buf.readUIntBE(38, 6);
+  if (buf.length === 46) {
+    return buf[20] === 1 ? { folderCounter, itemCounter: null } : null;
+  }
+  if (buf[20] !== 7) {
+    return null;
+  }
+  return { folderCounter, itemCounter: buf.readUIntBE(62, 6) };
+}
+
+// src/graph/exchange/timezones.generated.ts
+var WINDOWS_ZONES = [
+  {
+    alias: "Dateline Standard Time",
+    displayName: "(UTC-12:00) International Date Line West",
+    iana: "Etc/GMT+12",
+    ianaAll: ["Etc/GMT+12"]
+  },
+  {
+    alias: "UTC-11",
+    displayName: "(UTC-11:00) Coordinated Universal Time-11",
+    iana: "Etc/GMT+11",
+    ianaAll: ["Etc/GMT+11", "Pacific/Pago_Pago", "Pacific/Niue", "Pacific/Midway"]
+  },
+  {
+    alias: "Aleutian Standard Time",
+    displayName: "(UTC-10:00) Aleutian Islands",
+    iana: "America/Adak",
+    ianaAll: ["America/Adak"]
+  },
+  {
+    alias: "Hawaiian Standard Time",
+    displayName: "(UTC-10:00) Hawaii",
+    iana: "Pacific/Honolulu",
+    ianaAll: ["Pacific/Honolulu", "Pacific/Rarotonga", "Pacific/Tahiti", "Etc/GMT+10"]
+  },
+  {
+    alias: "Marquesas Standard Time",
+    displayName: "(UTC-09:30) Marquesas Islands",
+    iana: "Pacific/Marquesas",
+    ianaAll: ["Pacific/Marquesas"]
+  },
+  {
+    alias: "Alaskan Standard Time",
+    displayName: "(UTC-09:00) Alaska",
+    iana: "America/Anchorage",
+    ianaAll: [
+      "America/Anchorage",
+      "America/Juneau",
+      "America/Metlakatla",
+      "America/Nome",
+      "America/Sitka",
+      "America/Yakutat"
+    ]
+  },
+  {
+    alias: "UTC-09",
+    displayName: "(UTC-09:00) Coordinated Universal Time-09",
+    iana: "Etc/GMT+9",
+    ianaAll: ["Etc/GMT+9", "Pacific/Gambier"]
+  },
+  {
+    alias: "Pacific Standard Time (Mexico)",
+    displayName: "(UTC-08:00) Baja California",
+    iana: "America/Tijuana",
+    ianaAll: ["America/Tijuana"]
+  },
+  {
+    alias: "British Columbia Standard Time",
+    displayName: "(UTC-08:00) British Columbia",
+    iana: "America/Vancouver",
+    ianaAll: ["America/Vancouver"]
+  },
+  {
+    alias: "UTC-08",
+    displayName: "(UTC-08:00) Coordinated Universal Time-08",
+    iana: "Etc/GMT+8",
+    ianaAll: ["Etc/GMT+8", "Pacific/Pitcairn"]
+  },
+  {
+    alias: "Pacific Standard Time",
+    displayName: "(UTC-08:00) Pacific Time (US & Canada)",
+    iana: "America/Los_Angeles",
+    ianaAll: ["America/Los_Angeles"]
+  },
+  {
+    alias: "Alberta Standard Time",
+    displayName: "(UTC-07:00) Alberta",
+    iana: "America/Edmonton",
+    ianaAll: ["America/Edmonton", "America/Inuvik"]
+  },
+  {
+    alias: "US Mountain Standard Time",
+    displayName: "(UTC-07:00) Arizona",
+    iana: "America/Phoenix",
+    ianaAll: [
+      "America/Phoenix",
+      "America/Creston",
+      "America/Dawson_Creek",
+      "America/Fort_Nelson",
+      "America/Hermosillo",
+      "Etc/GMT+7"
+    ]
+  },
+  {
+    alias: "Mountain Standard Time (Mexico)",
+    displayName: "(UTC-07:00) La Paz, Mazatlan",
+    iana: "America/Mazatlan",
+    ianaAll: ["America/Mazatlan"]
+  },
+  {
+    alias: "Mountain Standard Time",
+    displayName: "(UTC-07:00) Mountain Time (US & Canada)",
+    iana: "America/Denver",
+    ianaAll: ["America/Denver", "America/Cambridge_Bay", "America/Ciudad_Juarez", "America/Boise"]
+  },
+  {
+    alias: "Yukon Standard Time",
+    displayName: "(UTC-07:00) Yukon",
+    iana: "America/Whitehorse",
+    ianaAll: ["America/Whitehorse", "America/Dawson"]
+  },
+  {
+    alias: "Central America Standard Time",
+    displayName: "(UTC-06:00) Central America",
+    iana: "America/Guatemala",
+    ianaAll: [
+      "America/Guatemala",
+      "America/Belize",
+      "America/Costa_Rica",
+      "Pacific/Galapagos",
+      "America/Tegucigalpa",
+      "America/Managua",
+      "America/El_Salvador",
+      "Etc/GMT+6"
+    ]
+  },
+  {
+    alias: "Central Standard Time",
+    displayName: "(UTC-06:00) Central Time (US & Canada)",
+    iana: "America/Chicago",
+    ianaAll: [
+      "America/Chicago",
+      "America/Rankin_Inlet",
+      "America/Resolute",
+      "America/Matamoros",
+      "America/Ojinaga",
+      "America/Indiana/Knox",
+      "America/Indiana/Tell_City",
+      "America/Menominee",
+      "America/North_Dakota/Beulah",
+      "America/North_Dakota/Center",
+      "America/North_Dakota/New_Salem"
+    ]
+  },
+  {
+    alias: "Easter Island Standard Time",
+    displayName: "(UTC-06:00) Easter Island",
+    iana: "Pacific/Easter",
+    ianaAll: ["Pacific/Easter"]
+  },
+  {
+    alias: "Central Standard Time (Mexico)",
+    displayName: "(UTC-06:00) Guadalajara, Mexico City, Monterrey",
+    iana: "America/Mexico_City",
+    ianaAll: [
+      "America/Mexico_City",
+      "America/Bahia_Banderas",
+      "America/Merida",
+      "America/Monterrey",
+      "America/Chihuahua",
+      ""
+    ]
+  },
+  {
+    alias: "Manitoba Standard Time",
+    displayName: "(UTC-06:00) Manitoba",
+    iana: "America/Winnipeg",
+    ianaAll: ["America/Winnipeg"]
+  },
+  {
+    alias: "Canada Central Standard Time",
+    displayName: "(UTC-06:00) Saskatchewan",
+    iana: "America/Regina",
+    ianaAll: ["America/Regina", "America/Swift_Current"]
+  },
+  {
+    alias: "SA Pacific Standard Time",
+    displayName: "(UTC-05:00) Bogota, Lima, Quito, Rio Branco",
+    iana: "America/Bogota",
+    ianaAll: [
+      "America/Bogota",
+      "America/Rio_Branco",
+      "America/Eirunepe",
+      "America/Coral_Harbour",
+      "America/Guayaquil",
+      "America/Jamaica",
+      "America/Cayman",
+      "America/Panama",
+      "America/Lima",
+      "Etc/GMT+5"
+    ]
+  },
+  {
+    alias: "Eastern Standard Time (Mexico)",
+    displayName: "(UTC-05:00) Chetumal",
+    iana: "America/Cancun",
+    ianaAll: ["America/Cancun"]
+  },
+  {
+    alias: "Eastern Standard Time",
+    displayName: "(UTC-05:00) Eastern Time (US & Canada)",
+    iana: "America/New_York",
+    ianaAll: [
+      "America/New_York",
+      "America/Nassau",
+      "America/Toronto",
+      "America/Iqaluit",
+      "America/Detroit",
+      "America/Indiana/Petersburg",
+      "America/Indiana/Vincennes",
+      "America/Indiana/Winamac",
+      "America/Kentucky/Monticello",
+      "America/Louisville"
+    ]
+  },
+  {
+    alias: "Haiti Standard Time",
+    displayName: "(UTC-05:00) Haiti",
+    iana: "America/Port-au-Prince",
+    ianaAll: ["America/Port-au-Prince"]
+  },
+  {
+    alias: "Cuba Standard Time",
+    displayName: "(UTC-05:00) Havana",
+    iana: "America/Havana",
+    ianaAll: ["America/Havana"]
+  },
+  {
+    alias: "US Eastern Standard Time",
+    displayName: "(UTC-05:00) Indiana (East)",
+    iana: "America/Indianapolis",
+    ianaAll: ["America/Indianapolis", "America/Indiana/Marengo", "America/Indiana/Vevay"]
+  },
+  {
+    alias: "Turks And Caicos Standard Time",
+    displayName: "(UTC-05:00) Turks and Caicos",
+    iana: "America/Grand_Turk",
+    ianaAll: ["America/Grand_Turk"]
+  },
+  {
+    alias: "Venezuela Standard Time",
+    displayName: "(UTC-04:30) Caracas",
+    iana: "America/Caracas",
+    ianaAll: ["America/Caracas"]
+  },
+  {
+    alias: "Paraguay Standard Time",
+    displayName: "(UTC-04:00) Asuncion",
+    iana: "America/Asuncion",
+    ianaAll: ["America/Asuncion"]
+  },
+  {
+    alias: "Atlantic Standard Time",
+    displayName: "(UTC-04:00) Atlantic Time (Canada)",
+    iana: "America/Halifax",
+    ianaAll: [
+      "America/Halifax",
+      "Atlantic/Bermuda",
+      "America/Glace_Bay",
+      "America/Goose_Bay",
+      "America/Moncton",
+      "America/Thule"
+    ]
+  },
+  {
+    alias: "Central Brazilian Standard Time",
+    displayName: "(UTC-04:00) Cuiaba",
+    iana: "America/Cuiaba",
+    ianaAll: ["America/Cuiaba", "America/Campo_Grande"]
+  },
+  {
+    alias: "SA Western Standard Time",
+    displayName: "(UTC-04:00) Georgetown, La Paz, Manaus, San Juan",
+    iana: "America/La_Paz",
+    ianaAll: [
+      "America/La_Paz",
+      "America/Antigua",
+      "America/Anguilla",
+      "America/Aruba",
+      "America/Barbados",
+      "America/St_Barthelemy",
+      "America/Kralendijk",
+      "America/Manaus",
+      "America/Boa_Vista",
+      "America/Porto_Velho",
+      "America/Blanc-Sablon",
+      "America/Curacao",
+      "America/Dominica",
+      "America/Santo_Domingo",
+      "America/Grenada",
+      "America/Guadeloupe",
+      "America/Guyana",
+      "America/St_Kitts",
+      "America/St_Lucia",
+      "America/Marigot",
+      "America/Martinique",
+      "America/Montserrat",
+      "America/Puerto_Rico",
+      "America/Lower_Princes",
+      "America/Port_of_Spain",
+      "America/St_Vincent",
+      "America/Tortola",
+      "America/St_Thomas",
+      "Etc/GMT+4"
+    ]
+  },
+  {
+    alias: "Newfoundland Standard Time",
+    displayName: "(UTC-03:30) Newfoundland",
+    iana: "America/St_Johns",
+    ianaAll: ["America/St_Johns"]
+  },
+  {
+    alias: "Tocantins Standard Time",
+    displayName: "(UTC-03:00) Araguaina",
+    iana: "America/Araguaina",
+    ianaAll: ["America/Araguaina"]
+  },
+  {
+    alias: "E. South America Standard Time",
+    displayName: "(UTC-03:00) Brasilia",
+    iana: "America/Sao_Paulo",
+    ianaAll: ["America/Sao_Paulo"]
+  },
+  {
+    alias: "SA Eastern Standard Time",
+    displayName: "(UTC-03:00) Cayenne, Fortaleza",
+    iana: "America/Cayenne",
+    ianaAll: [
+      "America/Cayenne",
+      "Antarctica/Rothera",
+      "Antarctica/Palmer",
+      "America/Fortaleza",
+      "America/Belem",
+      "America/Maceio",
+      "America/Recife",
+      "America/Santarem",
+      "Atlantic/Stanley",
+      "America/Paramaribo",
+      "Etc/GMT+3"
+    ]
+  },
+  {
+    alias: "Argentina Standard Time",
+    displayName: "(UTC-03:00) City of Buenos Aires",
+    iana: "America/Buenos_Aires",
+    ianaAll: [
+      "America/Buenos_Aires",
+      "America/Argentina/La_Rioja",
+      "America/Argentina/Rio_Gallegos",
+      "America/Argentina/Salta",
+      "America/Argentina/San_Juan",
+      "America/Argentina/San_Luis",
+      "America/Argentina/Tucuman",
+      "America/Argentina/Ushuaia",
+      "America/Catamarca",
+      "America/Cordoba",
+      "America/Jujuy",
+      "America/Mendoza"
+    ]
+  },
+  {
+    alias: "Greenland Standard Time",
+    displayName: "(UTC-03:00) Greenland",
+    iana: "America/Godthab",
+    ianaAll: ["America/Godthab"]
+  },
+  {
+    alias: "Montevideo Standard Time",
+    displayName: "(UTC-03:00) Montevideo",
+    iana: "America/Montevideo",
+    ianaAll: ["America/Montevideo"]
+  },
+  {
+    alias: "Magallanes Standard Time",
+    displayName: "(UTC-03:00) Punta Arenas",
+    iana: "America/Punta_Arenas",
+    ianaAll: ["America/Punta_Arenas", "America/Coyhaique"]
+  },
+  {
+    alias: "Saint Pierre Standard Time",
+    displayName: "(UTC-03:00) Saint Pierre and Miquelon",
+    iana: "America/Miquelon",
+    ianaAll: ["America/Miquelon"]
+  },
+  {
+    alias: "Bahia Standard Time",
+    displayName: "(UTC-03:00) Salvador",
+    iana: "America/Bahia",
+    ianaAll: ["America/Bahia"]
+  },
+  {
+    alias: "Pacific SA Standard Time",
+    displayName: "(UTC-03:00) Santiago",
+    iana: "America/Santiago",
+    ianaAll: ["America/Santiago"]
+  },
+  {
+    alias: "UTC-02",
+    displayName: "(UTC-02:00) Coordinated Universal Time-02",
+    iana: "Etc/GMT+2",
+    ianaAll: ["Etc/GMT+2", "America/Noronha", "Atlantic/South_Georgia"]
+  },
+  {
+    alias: "Azores Standard Time",
+    displayName: "(UTC-01:00) Azores",
+    iana: "Atlantic/Azores",
+    ianaAll: ["Atlantic/Azores", "America/Scoresbysund"]
+  },
+  {
+    alias: "Cape Verde Standard Time",
+    displayName: "(UTC-01:00) Cabo Verde Is.",
+    iana: "Atlantic/Cape_Verde",
+    ianaAll: ["Atlantic/Cape_Verde", "Etc/GMT+1"]
+  },
+  {
+    alias: "UTC",
+    displayName: "(UTC) Coordinated Universal Time",
+    iana: "Etc/UTC",
+    ianaAll: ["Etc/UTC", "Etc/GMT"]
+  },
+  {
+    alias: "Morocco Standard Time",
+    displayName: "(UTC+00:00) Casablanca",
+    iana: "Africa/Casablanca",
+    ianaAll: ["Africa/Casablanca", "Africa/El_Aaiun"]
+  },
+  {
+    alias: "GMT Standard Time",
+    displayName: "(UTC+00:00) Dublin, Edinburgh, Lisbon, London",
+    iana: "Europe/London",
+    ianaAll: [
+      "Europe/London",
+      "Atlantic/Canary",
+      "Atlantic/Faeroe",
+      "Europe/Guernsey",
+      "Europe/Dublin",
+      "Europe/Isle_of_Man",
+      "Europe/Jersey",
+      "Europe/Lisbon",
+      "Atlantic/Madeira"
+    ]
+  },
+  {
+    alias: "Greenwich Standard Time",
+    displayName: "(UTC+00:00) Monrovia, Reykjavik",
+    iana: "Atlantic/Reykjavik",
+    ianaAll: [
+      "Atlantic/Reykjavik",
+      "Africa/Ouagadougou",
+      "Africa/Abidjan",
+      "Africa/Accra",
+      "America/Danmarkshavn",
+      "Africa/Banjul",
+      "Africa/Conakry",
+      "Africa/Bissau",
+      "Africa/Monrovia",
+      "Africa/Bamako",
+      "Africa/Nouakchott",
+      "Atlantic/St_Helena",
+      "Africa/Freetown",
+      "Africa/Dakar",
+      "Africa/Lome"
+    ]
+  },
+  {
+    alias: "Sao Tome Standard Time",
+    displayName: "(UTC+00:00) Sao Tome",
+    iana: "Africa/Sao_Tome",
+    ianaAll: ["Africa/Sao_Tome"]
+  },
+  {
+    alias: "W. Europe Standard Time",
+    displayName: "(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna",
+    iana: "Europe/Berlin",
+    ianaAll: [
+      "Europe/Berlin",
+      "Europe/Andorra",
+      "Europe/Vienna",
+      "Europe/Zurich",
+      "Europe/Busingen",
+      "Europe/Gibraltar",
+      "Europe/Rome",
+      "Europe/Vaduz",
+      "Europe/Luxembourg",
+      "Europe/Monaco",
+      "Europe/Malta",
+      "Europe/Amsterdam",
+      "Europe/Oslo",
+      "Europe/Stockholm",
+      "Arctic/Longyearbyen",
+      "Europe/San_Marino",
+      "Europe/Vatican"
+    ]
+  },
+  {
+    alias: "Central Europe Standard Time",
+    displayName: "(UTC+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague",
+    iana: "Europe/Budapest",
+    ianaAll: [
+      "Europe/Budapest",
+      "Europe/Tirane",
+      "Europe/Prague",
+      "Europe/Podgorica",
+      "Europe/Belgrade",
+      "Europe/Ljubljana",
+      "Europe/Bratislava"
+    ]
+  },
+  {
+    alias: "Romance Standard Time",
+    displayName: "(UTC+01:00) Brussels, Copenhagen, Madrid, Paris",
+    iana: "Europe/Paris",
+    ianaAll: ["Europe/Paris", "Europe/Brussels", "Europe/Copenhagen", "Europe/Madrid", "Africa/Ceuta"]
+  },
+  {
+    alias: "Central European Standard Time",
+    displayName: "(UTC+01:00) Sarajevo, Skopje, Warsaw, Zagreb",
+    iana: "Europe/Warsaw",
+    ianaAll: ["Europe/Warsaw", "Europe/Sarajevo", "Europe/Zagreb", "Europe/Skopje"]
+  },
+  {
+    alias: "W. Central Africa Standard Time",
+    displayName: "(UTC+01:00) West Central Africa",
+    iana: "Africa/Lagos",
+    ianaAll: [
+      "Africa/Lagos",
+      "Africa/Luanda",
+      "Africa/Porto-Novo",
+      "Africa/Kinshasa",
+      "Africa/Bangui",
+      "Africa/Brazzaville",
+      "Africa/Douala",
+      "Africa/Algiers",
+      "Africa/Libreville",
+      "Africa/Malabo",
+      "Africa/Niamey",
+      "Africa/Ndjamena",
+      "Africa/Tunis",
+      "Etc/GMT-1"
+    ]
+  },
+  {
+    alias: "Namibia Standard Time",
+    displayName: "(UTC+01:00) Windhoek",
+    iana: "Africa/Windhoek",
+    ianaAll: ["Africa/Windhoek"]
+  },
+  {
+    alias: "Jordan Standard Time",
+    displayName: "(UTC+02:00) Amman",
+    iana: "Asia/Amman",
+    ianaAll: ["Asia/Amman"]
+  },
+  {
+    alias: "GTB Standard Time",
+    displayName: "(UTC+02:00) Athens, Bucharest",
+    iana: "Europe/Bucharest",
+    ianaAll: ["Europe/Bucharest", "Asia/Nicosia", "Asia/Famagusta", "Europe/Athens"]
+  },
+  {
+    alias: "Middle East Standard Time",
+    displayName: "(UTC+02:00) Beirut",
+    iana: "Asia/Beirut",
+    ianaAll: ["Asia/Beirut"]
+  },
+  {
+    alias: "Egypt Standard Time",
+    displayName: "(UTC+02:00) Cairo",
+    iana: "Africa/Cairo",
+    ianaAll: ["Africa/Cairo"]
+  },
+  {
+    alias: "Syria Standard Time",
+    displayName: "(UTC+02:00) Damascus",
+    iana: "Asia/Damascus",
+    ianaAll: ["Asia/Damascus"]
+  },
+  {
+    alias: "E. Europe Standard Time",
+    displayName: "(UTC+02:00) E. Europe",
+    iana: "Europe/Chisinau",
+    ianaAll: ["Europe/Chisinau"]
+  },
+  {
+    alias: "West Bank Standard Time",
+    displayName: "(UTC+02:00) Gaza, Hebron",
+    iana: "Asia/Hebron",
+    ianaAll: ["Asia/Hebron", "Asia/Gaza"]
+  },
+  {
+    alias: "South Africa Standard Time",
+    displayName: "(UTC+02:00) Harare, Pretoria",
+    iana: "Africa/Johannesburg",
+    ianaAll: [
+      "Africa/Johannesburg",
+      "Africa/Bujumbura",
+      "Africa/Gaborone",
+      "Africa/Lubumbashi",
+      "Africa/Maseru",
+      "Africa/Blantyre",
+      "Africa/Maputo",
+      "Africa/Kigali",
+      "Africa/Mbabane",
+      "Africa/Lusaka",
+      "Africa/Harare",
+      "Etc/GMT-2"
+    ]
+  },
+  {
+    alias: "FLE Standard Time",
+    displayName: "(UTC+02:00) Helsinki, Kyiv, Riga, Sofia, Tallinn, Vilnius",
+    iana: "Europe/Kiev",
+    ianaAll: [
+      "Europe/Kiev",
+      "Europe/Mariehamn",
+      "Europe/Sofia",
+      "Europe/Tallinn",
+      "Europe/Helsinki",
+      "Europe/Vilnius",
+      "Europe/Riga"
+    ]
+  },
+  {
+    alias: "South Sudan Standard Time",
+    displayName: "(UTC+02:00) Juba",
+    iana: "Africa/Juba",
+    ianaAll: ["Africa/Juba"]
+  },
+  {
+    alias: "Kaliningrad Standard Time",
+    displayName: "(UTC+02:00) Kaliningrad",
+    iana: "Europe/Kaliningrad",
+    ianaAll: ["Europe/Kaliningrad"]
+  },
+  {
+    alias: "Sudan Standard Time",
+    displayName: "(UTC+02:00) Khartoum",
+    iana: "Africa/Khartoum",
+    ianaAll: ["Africa/Khartoum"]
+  },
+  {
+    alias: "Israel Standard Time",
+    displayName: "(UTC+02:00) Middle East",
+    iana: "Asia/Jerusalem",
+    ianaAll: ["Asia/Jerusalem"]
+  },
+  {
+    alias: "Libya Standard Time",
+    displayName: "(UTC+02:00) Tripoli",
+    iana: "Africa/Tripoli",
+    ianaAll: ["Africa/Tripoli"]
+  },
+  {
+    alias: "Arabic Standard Time",
+    displayName: "(UTC+03:00) Baghdad",
+    iana: "Asia/Baghdad",
+    ianaAll: ["Asia/Baghdad"]
+  },
+  {
+    alias: "Turkey Standard Time",
+    displayName: "(UTC+03:00) Istanbul",
+    iana: "Europe/Istanbul",
+    ianaAll: ["Europe/Istanbul"]
+  },
+  {
+    alias: "Arab Standard Time",
+    displayName: "(UTC+03:00) Kuwait, Riyadh",
+    iana: "Asia/Riyadh",
+    ianaAll: ["Asia/Riyadh", "Asia/Bahrain", "Asia/Kuwait", "Asia/Qatar", "Asia/Aden"]
+  },
+  {
+    alias: "Belarus Standard Time",
+    displayName: "(UTC+03:00) Minsk",
+    iana: "Europe/Minsk",
+    ianaAll: ["Europe/Minsk"]
+  },
+  {
+    alias: "Russian Standard Time",
+    displayName: "(UTC+03:00) Moscow, St. Petersburg, Volgograd (RTZ 2)",
+    iana: "Europe/Moscow",
+    ianaAll: ["Europe/Moscow", "Europe/Kirov", "Europe/Simferopol"]
+  },
+  {
+    alias: "E. Africa Standard Time",
+    displayName: "(UTC+03:00) Nairobi",
+    iana: "Africa/Nairobi",
+    ianaAll: [
+      "Africa/Nairobi",
+      "Antarctica/Syowa",
+      "Africa/Djibouti",
+      "Africa/Asmera",
+      "Africa/Addis_Ababa",
+      "Indian/Comoro",
+      "Indian/Antananarivo",
+      "Africa/Mogadishu",
+      "Africa/Dar_es_Salaam",
+      "Africa/Kampala",
+      "Indian/Mayotte",
+      "Etc/GMT-3"
+    ]
+  },
+  {
+    alias: "Volgograd Standard Time",
+    displayName: "(UTC+03:00) Volgograd",
+    iana: "Europe/Volgograd",
+    ianaAll: ["Europe/Volgograd"]
+  },
+  {
+    alias: "Iran Standard Time",
+    displayName: "(UTC+03:30) Tehran",
+    iana: "Asia/Tehran",
+    ianaAll: ["Asia/Tehran"]
+  },
+  {
+    alias: "Arabian Standard Time",
+    displayName: "(UTC+04:00) Abu Dhabi, Muscat",
+    iana: "Asia/Dubai",
+    ianaAll: ["Asia/Dubai", "Asia/Muscat", "Etc/GMT-4"]
+  },
+  {
+    alias: "Astrakhan Standard Time",
+    displayName: "(UTC+04:00) Astrakhan, Ulyanovsk",
+    iana: "Europe/Astrakhan",
+    ianaAll: ["Europe/Astrakhan", "Europe/Ulyanovsk"]
+  },
+  {
+    alias: "Azerbaijan Standard Time",
+    displayName: "(UTC+04:00) Baku",
+    iana: "Asia/Baku",
+    ianaAll: ["Asia/Baku"]
+  },
+  {
+    alias: "Russia Time Zone 3",
+    displayName: "(UTC+04:00) Izhevsk, Samara",
+    iana: "Europe/Samara",
+    ianaAll: ["Europe/Samara"]
+  },
+  {
+    alias: "Mauritius Standard Time",
+    displayName: "(UTC+04:00) Port Louis",
+    iana: "Indian/Mauritius",
+    ianaAll: ["Indian/Mauritius", "Indian/Reunion", "Indian/Mahe"]
+  },
+  {
+    alias: "Saratov Standard Time",
+    displayName: "(UTC+04:00) Saratov",
+    iana: "Europe/Saratov",
+    ianaAll: ["Europe/Saratov"]
+  },
+  {
+    alias: "Georgian Standard Time",
+    displayName: "(UTC+04:00) Tbilisi",
+    iana: "Asia/Tbilisi",
+    ianaAll: ["Asia/Tbilisi"]
+  },
+  {
+    alias: "Caucasus Standard Time",
+    displayName: "(UTC+04:00) Yerevan",
+    iana: "Asia/Yerevan",
+    ianaAll: ["Asia/Yerevan"]
+  },
+  {
+    alias: "Afghanistan Standard Time",
+    displayName: "(UTC+04:30) Kabul",
+    iana: "Asia/Kabul",
+    ianaAll: ["Asia/Kabul"]
+  },
+  {
+    alias: "West Asia Standard Time",
+    displayName: "(UTC+05:00) Ashgabat, Tashkent",
+    iana: "Asia/Tashkent",
+    ianaAll: [
+      "Asia/Tashkent",
+      "Antarctica/Mawson",
+      "Asia/Oral",
+      "Asia/Almaty",
+      "Asia/Aqtau",
+      "Asia/Aqtobe",
+      "Asia/Atyrau",
+      "Asia/Qostanay",
+      "Indian/Maldives",
+      "Indian/Kerguelen",
+      "Asia/Dushanbe",
+      "Asia/Ashgabat",
+      "Asia/Samarkand",
+      "Etc/GMT-5"
+    ]
+  },
+  {
+    alias: "Ekaterinburg Standard Time",
+    displayName: "(UTC+05:00) Ekaterinburg",
+    iana: "Asia/Yekaterinburg",
+    ianaAll: ["Asia/Yekaterinburg"]
+  },
+  {
+    alias: "Pakistan Standard Time",
+    displayName: "(UTC+05:00) Islamabad, Karachi",
+    iana: "Asia/Karachi",
+    ianaAll: ["Asia/Karachi"]
+  },
+  {
+    alias: "Qyzylorda Standard Time",
+    displayName: "(UTC+05:00) Qyzylorda",
+    iana: "Asia/Qyzylorda",
+    ianaAll: ["Asia/Qyzylorda"]
+  },
+  {
+    alias: "India Standard Time",
+    displayName: "(UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi",
+    iana: "Asia/Calcutta",
+    ianaAll: ["Asia/Calcutta"]
+  },
+  {
+    alias: "Sri Lanka Standard Time",
+    displayName: "(UTC+05:30) Sri Jayawardenepura",
+    iana: "Asia/Colombo",
+    ianaAll: ["Asia/Colombo"]
+  },
+  {
+    alias: "Nepal Standard Time",
+    displayName: "(UTC+05:45) Kathmandu",
+    iana: "Asia/Katmandu",
+    ianaAll: ["Asia/Katmandu"]
+  },
+  {
+    alias: "Central Asia Standard Time",
+    displayName: "(UTC+06:00) Astana",
+    iana: "Asia/Bishkek",
+    ianaAll: ["Asia/Bishkek", "Antarctica/Vostok", "Asia/Urumqi", "Indian/Chagos", "Etc/GMT-6"]
+  },
+  {
+    alias: "Bangladesh Standard Time",
+    displayName: "(UTC+06:00) Dhaka",
+    iana: "Asia/Dhaka",
+    ianaAll: ["Asia/Dhaka", "Asia/Thimphu"]
+  },
+  {
+    alias: "Omsk Standard Time",
+    displayName: "(UTC+06:00) Omsk",
+    iana: "Asia/Omsk",
+    ianaAll: ["Asia/Omsk"]
+  },
+  {
+    alias: "Myanmar Standard Time",
+    displayName: "(UTC+06:30) Yangon (Rangoon)",
+    iana: "Asia/Rangoon",
+    ianaAll: ["Asia/Rangoon", "Indian/Cocos"]
+  },
+  {
+    alias: "SE Asia Standard Time",
+    displayName: "(UTC+07:00) Bangkok, Hanoi, Jakarta",
+    iana: "Asia/Bangkok",
+    ianaAll: [
+      "Asia/Bangkok",
+      "Antarctica/Davis",
+      "Indian/Christmas",
+      "Asia/Jakarta",
+      "Asia/Pontianak",
+      "Asia/Phnom_Penh",
+      "Asia/Vientiane",
+      "Asia/Saigon",
+      "Etc/GMT-7"
+    ]
+  },
+  {
+    alias: "Altai Standard Time",
+    displayName: "(UTC+07:00) Barnaul, Gorno-Altaysk",
+    iana: "Asia/Barnaul",
+    ianaAll: ["Asia/Barnaul"]
+  },
+  {
+    alias: "W. Mongolia Standard Time",
+    displayName: "(UTC+07:00) Hovd",
+    iana: "Asia/Hovd",
+    ianaAll: ["Asia/Hovd"]
+  },
+  {
+    alias: "North Asia Standard Time",
+    displayName: "(UTC+07:00) Krasnoyarsk",
+    iana: "Asia/Krasnoyarsk",
+    ianaAll: ["Asia/Krasnoyarsk", "Asia/Novokuznetsk"]
+  },
+  {
+    alias: "N. Central Asia Standard Time",
+    displayName: "(UTC+07:00) Novosibirsk",
+    iana: "Asia/Novosibirsk",
+    ianaAll: ["Asia/Novosibirsk"]
+  },
+  {
+    alias: "Tomsk Standard Time",
+    displayName: "(UTC+07:00) Tomsk",
+    iana: "Asia/Tomsk",
+    ianaAll: ["Asia/Tomsk"]
+  },
+  {
+    alias: "China Standard Time",
+    displayName: "(UTC+08:00) Beijing, Chongqing, Hong Kong SAR, Urumqi",
+    iana: "Asia/Shanghai",
+    ianaAll: ["Asia/Shanghai", "Asia/Hong_Kong", "Asia/Macau"]
+  },
+  {
+    alias: "North Asia East Standard Time",
+    displayName: "(UTC+08:00) Irkutsk",
+    iana: "Asia/Irkutsk",
+    ianaAll: ["Asia/Irkutsk"]
+  },
+  {
+    alias: "Singapore Standard Time",
+    displayName: "(UTC+08:00) Kuala Lumpur, Singapore",
+    iana: "Asia/Singapore",
+    ianaAll: [
+      "Asia/Singapore",
+      "Asia/Brunei",
+      "Asia/Makassar",
+      "Asia/Kuala_Lumpur",
+      "Asia/Kuching",
+      "Asia/Manila",
+      "Etc/GMT-8"
+    ]
+  },
+  {
+    alias: "W. Australia Standard Time",
+    displayName: "(UTC+08:00) Perth",
+    iana: "Australia/Perth",
+    ianaAll: ["Australia/Perth"]
+  },
+  {
+    alias: "Taipei Standard Time",
+    displayName: "(UTC+08:00) Taipei",
+    iana: "Asia/Taipei",
+    ianaAll: ["Asia/Taipei"]
+  },
+  {
+    alias: "Ulaanbaatar Standard Time",
+    displayName: "(UTC+08:00) Ulaanbaatar",
+    iana: "Asia/Ulaanbaatar",
+    ianaAll: ["Asia/Ulaanbaatar"]
+  },
+  {
+    alias: "Aus Central W. Standard Time",
+    displayName: "(UTC+08:45) Eucla",
+    iana: "Australia/Eucla",
+    ianaAll: ["Australia/Eucla"]
+  },
+  {
+    alias: "Transbaikal Standard Time",
+    displayName: "(UTC+09:00) Chita",
+    iana: "Asia/Chita",
+    ianaAll: ["Asia/Chita"]
+  },
+  {
+    alias: "Tokyo Standard Time",
+    displayName: "(UTC+09:00) Osaka, Sapporo, Tokyo",
+    iana: "Asia/Tokyo",
+    ianaAll: ["Asia/Tokyo", "Asia/Jayapura", "Pacific/Palau", "Asia/Dili", "Etc/GMT-9"]
+  },
+  {
+    alias: "North Korea Standard Time",
+    displayName: "(UTC+09:00) Pyongyang",
+    iana: "Asia/Pyongyang",
+    ianaAll: ["Asia/Pyongyang"]
+  },
+  {
+    alias: "Korea Standard Time",
+    displayName: "(UTC+09:00) Seoul",
+    iana: "Asia/Seoul",
+    ianaAll: ["Asia/Seoul"]
+  },
+  {
+    alias: "Yakutsk Standard Time",
+    displayName: "(UTC+09:00) Yakutsk",
+    iana: "Asia/Yakutsk",
+    ianaAll: ["Asia/Yakutsk", "Asia/Khandyga"]
+  },
+  {
+    alias: "Cen. Australia Standard Time",
+    displayName: "(UTC+09:30) Adelaide",
+    iana: "Australia/Adelaide",
+    ianaAll: ["Australia/Adelaide", "Australia/Broken_Hill"]
+  },
+  {
+    alias: "AUS Central Standard Time",
+    displayName: "(UTC+09:30) Darwin",
+    iana: "Australia/Darwin",
+    ianaAll: ["Australia/Darwin"]
+  },
+  {
+    alias: "E. Australia Standard Time",
+    displayName: "(UTC+10:00) Brisbane",
+    iana: "Australia/Brisbane",
+    ianaAll: ["Australia/Brisbane", "Australia/Lindeman"]
+  },
+  {
+    alias: "AUS Eastern Standard Time",
+    displayName: "(UTC+10:00) Canberra, Melbourne, Sydney",
+    iana: "Australia/Sydney",
+    ianaAll: ["Australia/Sydney", "Australia/Melbourne"]
+  },
+  {
+    alias: "West Pacific Standard Time",
+    displayName: "(UTC+10:00) Guam, Port Moresby",
+    iana: "Pacific/Port_Moresby",
+    ianaAll: [
+      "Pacific/Port_Moresby",
+      "Antarctica/DumontDUrville",
+      "Pacific/Truk",
+      "Pacific/Guam",
+      "Pacific/Saipan",
+      "Etc/GMT-10"
+    ]
+  },
+  {
+    alias: "Tasmania Standard Time",
+    displayName: "(UTC+10:00) Hobart",
+    iana: "Australia/Hobart",
+    ianaAll: ["Australia/Hobart", "Antarctica/Macquarie"]
+  },
+  {
+    alias: "Vladivostok Standard Time",
+    displayName: "(UTC+10:00) Vladivostok",
+    iana: "Asia/Vladivostok",
+    ianaAll: ["Asia/Vladivostok", "Asia/Ust-Nera"]
+  },
+  {
+    alias: "Lord Howe Standard Time",
+    displayName: "(UTC+10:30) Lord Howe Island",
+    iana: "Australia/Lord_Howe",
+    ianaAll: ["Australia/Lord_Howe"]
+  },
+  {
+    alias: "Bougainville Standard Time",
+    displayName: "(UTC+11:00) Bougainville Island",
+    iana: "Pacific/Bougainville",
+    ianaAll: ["Pacific/Bougainville"]
+  },
+  {
+    alias: "Russia Time Zone 10",
+    displayName: "(UTC+11:00) Chokurdakh",
+    iana: "Asia/Srednekolymsk",
+    ianaAll: ["Asia/Srednekolymsk"]
+  },
+  {
+    alias: "Magadan Standard Time",
+    displayName: "(UTC+11:00) Magadan",
+    iana: "Asia/Magadan",
+    ianaAll: ["Asia/Magadan"]
+  },
+  {
+    alias: "Norfolk Standard Time",
+    displayName: "(UTC+11:00) Norfolk Island",
+    iana: "Pacific/Norfolk",
+    ianaAll: ["Pacific/Norfolk"]
+  },
+  {
+    alias: "Sakhalin Standard Time",
+    displayName: "(UTC+11:00) Sakhalin",
+    iana: "Asia/Sakhalin",
+    ianaAll: ["Asia/Sakhalin"]
+  },
+  {
+    alias: "Central Pacific Standard Time",
+    displayName: "(UTC+11:00) Solomon Is., New Caledonia",
+    iana: "Pacific/Guadalcanal",
+    ianaAll: [
+      "Pacific/Guadalcanal",
+      "Antarctica/Casey",
+      "Pacific/Ponape",
+      "Pacific/Kosrae",
+      "Pacific/Noumea",
+      "Pacific/Efate",
+      "Etc/GMT-11"
+    ]
+  },
+  {
+    alias: "Russia Time Zone 11",
+    displayName: "(UTC+12:00) Anadyr, Petropavlovsk-Kamchatsky",
+    iana: "Asia/Kamchatka",
+    ianaAll: ["Asia/Kamchatka", "Asia/Anadyr"]
+  },
+  {
+    alias: "New Zealand Standard Time",
+    displayName: "(UTC+12:00) Auckland, Wellington",
+    iana: "Pacific/Auckland",
+    ianaAll: ["Pacific/Auckland", "Antarctica/McMurdo"]
+  },
+  {
+    alias: "UTC+12",
+    displayName: "(UTC+12:00) Coordinated Universal Time+12",
+    iana: "Etc/GMT-12",
+    ianaAll: [
+      "Etc/GMT-12",
+      "Pacific/Tarawa",
+      "Pacific/Majuro",
+      "Pacific/Kwajalein",
+      "Pacific/Nauru",
+      "Pacific/Funafuti",
+      "Pacific/Wake",
+      "Pacific/Wallis"
+    ]
+  },
+  {
+    alias: "Fiji Standard Time",
+    displayName: "(UTC+12:00) Fiji",
+    iana: "Pacific/Fiji",
+    ianaAll: ["Pacific/Fiji"]
+  },
+  {
+    alias: "Chatham Islands Standard Time",
+    displayName: "(UTC+12:45) Chatham Islands",
+    iana: "Pacific/Chatham",
+    ianaAll: ["Pacific/Chatham"]
+  },
+  {
+    alias: "UTC+13",
+    displayName: "(UTC+13:00) Coordinated Universal Time+13",
+    iana: "Etc/GMT-13",
+    ianaAll: ["Etc/GMT-13", "Pacific/Enderbury", "Pacific/Fakaofo"]
+  },
+  {
+    alias: "Tonga Standard Time",
+    displayName: "(UTC+13:00) Nuku'alofa",
+    iana: "Pacific/Tongatapu",
+    ianaAll: ["Pacific/Tongatapu"]
+  },
+  {
+    alias: "Samoa Standard Time",
+    displayName: "(UTC+13:00) Samoa",
+    iana: "Pacific/Apia",
+    ianaAll: ["Pacific/Apia"]
+  },
+  {
+    alias: "Line Islands Standard Time",
+    displayName: "(UTC+14:00) Kiritimati Island",
+    iana: "Pacific/Kiritimati",
+    ianaAll: ["Pacific/Kiritimati", "Etc/GMT-14"]
+  }
+];
+
+// src/graph/exchange/timezones.ts
+var TIMEZONE_ABBREVIATION = /^[A-Za-z]{2,5}$/;
+var byWindows = new Map(WINDOWS_ZONES.map((z) => [z.alias.toLowerCase(), z]));
+var byIana = /* @__PURE__ */ new Map();
+for (const z of WINDOWS_ZONES) {
+  for (const i of z.ianaAll) {
+    if (!byIana.has(i.toLowerCase())) {
+      byIana.set(i.toLowerCase(), z);
+    }
+  }
+}
+function validIana(name) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: name }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+}
+function resolveZone(name) {
+  if (!name) {
+    return null;
+  }
+  const trimmed = name.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower === "utc" || lower === "etc/utc" || lower === "coordinated universal time") {
+    return { iana: "UTC", windows: byWindows.get("utc") ?? null };
+  }
+  const w = byWindows.get(lower);
+  if (w) {
+    return { iana: w.iana, windows: w };
+  }
+  if (TIMEZONE_ABBREVIATION.test(trimmed) && lower !== "gmt") {
+    return null;
+  }
+  const iana = validIana(trimmed);
+  if (iana) {
+    return { iana, windows: byIana.get(iana.toLowerCase()) ?? byIana.get(lower) ?? null };
+  }
+  return null;
+}
+function offsetAt(iana, at) {
+  if (iana === "UTC") {
+    return 0;
+  }
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: iana,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).formatToParts(at);
+  const get = (t) => Number(parts.find((p) => p.type === t)?.value ?? 0);
+  const asUtc = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour"), get("minute"), get("second"));
+  return Math.round((asUtc - Math.floor(at.getTime() / 1e3) * 1e3) / 6e4);
+}
+var LOCAL_RE = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,7}))?)?)?(Z|[+-]\d{2}:\d{2})?$/;
+function parseLocal(s) {
+  const m = LOCAL_RE.exec(s.trim());
+  if (!m) {
+    return null;
+  }
+  const [, y, mo, d, h = "0", mi = "0", se = "0", frac = "0", off] = m;
+  const ms = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(se)) + Math.floor(Number(`0.${frac}`) * 1e3);
+  if (Number(mo) < 1 || Number(mo) > 12 || Number(d) < 1 || Number(d) > 31 || Number(h) > 23 || Number(mi) > 59) {
+    return null;
+  }
+  let offsetMinutes = null;
+  if (off === "Z") {
+    offsetMinutes = 0;
+  } else if (off) {
+    offsetMinutes = (off[0] === "-" ? -1 : 1) * (Number(off.slice(1, 3)) * 60 + Number(off.slice(4, 6)));
+  }
+  return { ms, offsetMinutes };
+}
+function wallToUtc(wallMs, iana) {
+  if (iana === "UTC") {
+    return wallMs;
+  }
+  let guess = wallMs - offsetAt(iana, new Date(wallMs)) * 6e4;
+  for (let i = 0; i < 3; i += 1) {
+    const next = wallMs - offsetAt(iana, new Date(guess)) * 6e4;
+    if (next === guess) {
+      break;
+    }
+    guess = next;
+  }
+  return guess;
+}
+function utcToWall(utcMs, iana) {
+  return utcMs + offsetAt(iana, new Date(utcMs)) * 6e4;
+}
+function formatGraphDateTime(wallMs) {
+  const iso = new Date(wallMs).toISOString();
+  return `${iso.slice(0, 19)}.${iso.slice(20, 23)}0000`;
+}
+function displayZoneName(input, zone) {
+  if (zone.windows && zone.windows.alias.toLowerCase() === input.trim().toLowerCase()) {
+    return zone.windows.alias;
+  }
+  if (input.trim().toLowerCase() === "utc") {
+    return "UTC";
+  }
+  return zone.iana;
+}
+
+// src/graph/exchange/exchange.ts
+import { randomBytes as randomBytes2, randomUUID } from "crypto";
+var MILLISECONDS_SUFFIX = /\.\d{3}Z$/;
+var STATE_KEY = "microsoft.exchange";
+var DEFAULT_TREE = {
+  name: "Root",
+  isHidden: true,
+  children: [
+    {
+      name: "Top of Information Store",
+      wellKnownName: "msgfolderroot",
+      children: [
+        { name: "Archive", wellKnownName: "archive" },
+        { name: "Calendar", wellKnownName: "calendar", folderClass: "IPF.Appointment" },
+        { name: "Clutter", wellKnownName: "clutter" },
+        { name: "Contacts", wellKnownName: "contacts", folderClass: "IPF.Contact" },
+        { name: "Conversation Action Settings", folderClass: "IPF.Configuration", isHidden: true },
+        {
+          name: "Conversation History",
+          wellKnownName: "conversationhistory",
+          children: [{ name: "Team Chat", folderClass: "IPF.SkypeTeams.Message" }]
+        },
+        { name: "Deleted Items", wellKnownName: "deleteditems" },
+        { name: "Drafts", wellKnownName: "drafts" },
+        { name: "ExternalContacts", folderClass: "IPF.Contact", isHidden: true },
+        { name: "Files", folderClass: "IPF.Files", isHidden: true },
+        { name: "Inbox", wellKnownName: "inbox", baseSize: 1484 },
+        { name: "Journal", folderClass: "IPF.Journal" },
+        { name: "Junk Email", wellKnownName: "junkemail" },
+        { name: "Notes", folderClass: "IPF.StickyNote" },
+        { name: "Outbox", wellKnownName: "outbox" },
+        { name: "Sent Items", wellKnownName: "sentitems" },
+        { name: "Snoozed", wellKnownName: "scheduled" },
+        { name: "Tasks", wellKnownName: "tasks", folderClass: "IPF.Task" }
+      ]
+    },
+    { name: "Finder", wellKnownName: "searchfolders", folderClass: "IPF" },
+    {
+      name: "Recoverable Items",
+      wellKnownName: "recoverableitemsroot",
+      isHidden: true,
+      children: [
+        { name: "Deletions", wellKnownName: "recoverableitemsdeletions" },
+        { name: "Purges", wellKnownName: "recoverableitemspurges" },
+        { name: "Versions", wellKnownName: "recoverableitemsversions" }
+      ]
+    }
+  ]
+};
+var ABSENT_WELL_KNOWN = /* @__PURE__ */ new Set(["syncissues", "conflicts", "localfailures", "serverfailures"]);
+var MAIL_WELL_KNOWN = /* @__PURE__ */ new Set([
+  "archive",
+  "clutter",
+  "conversationhistory",
+  "deleteditems",
+  "drafts",
+  "inbox",
+  "junkemail",
+  "msgfolderroot",
+  "outbox",
+  "recoverableitemsdeletions",
+  "scheduled",
+  "searchfolders",
+  "sentitems",
+  "recoverableitemsroot",
+  "recoverableitemspurges",
+  "recoverableitemsversions"
+]);
+var DEFAULT_CONFIG = {
+  deliveryDelayMs: 1e3,
+  strictAuth: false,
+  applicationAccessPolicies: {}
+};
+var USER_PURPOSE = { shared: "shared", room: "room" };
+function defaultSettings(kind) {
+  return {
+    archiveFolder: "",
+    timeZone: "UTC",
+    automaticRepliesSetting: {
+      status: "disabled",
+      externalAudience: "all",
+      internalReplyMessage: "",
+      externalReplyMessage: "",
+      scheduledStartDateTime: { dateTime: "2026-01-01T00:00:00.0000000", timeZone: "UTC" },
+      scheduledEndDateTime: { dateTime: "2026-01-02T00:00:00.0000000", timeZone: "UTC" }
+    },
+    language: { locale: "en-US", displayName: "English (United States)" },
+    dateFormat: "M/d/yyyy",
+    timeFormat: "h:mm tt",
+    delegateMeetingMessageDeliveryOptions: "sendToDelegateOnly",
+    userPurpose: USER_PURPOSE[kind] ?? "user",
+    unset: ["timeZone", "language", "dateFormat", "timeFormat", "workingHours"],
+    workingHours: {
+      daysOfWeek: ["monday", "tuesday", "wednesday", "thursday", "friday"],
+      startTime: "08:00:00.0000000",
+      endTime: "17:00:00.0000000",
+      timeZone: { name: "UTC" }
+    }
+  };
+}
+function isoSeconds(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().replace(MILLISECONDS_SUFFIX, "Z");
+}
+function guidHex() {
+  return randomBytes2(16).toString("hex");
+}
+var Exchange = class _Exchange {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Evaluates a search folder's query. Installed by the OData layer so the
+   * store does not depend on the filter engine.
+   */
+  static searchResolver = null;
+  get state() {
+    let st = this.store.getData(STATE_KEY);
+    if (!st) {
+      st = {
+        version: 1,
+        tenantId: "",
+        domain: "",
+        mailboxes: {},
+        byAddress: {},
+        permissions: [],
+        subscriptions: [],
+        uploadSessions: {},
+        pending: [],
+        config: { ...DEFAULT_CONFIG }
+      };
+      this.store.setData(STATE_KEY, st);
+    }
+    return st;
+  }
+  get config() {
+    return this.state.config;
+  }
+  // ---------------------------------------------------------------------------
+  // Mailboxes
+  // ---------------------------------------------------------------------------
+  ensureMailbox(init) {
+    const key = init.address.toLowerCase();
+    const existing = this.state.byAddress[key];
+    if (existing) {
+      const mbx2 = this.state.mailboxes[existing];
+      mbx2.displayName = init.displayName;
+      return mbx2;
+    }
+    const guid = randomUUID();
+    const mbx = {
+      guid,
+      address: init.address,
+      displayName: init.displayName,
+      userOid: init.userOid,
+      kind: init.kind,
+      store: { ...newStoreIdentity(guid), ...init.standardIds ? { standardIds: true } : {} },
+      nextCounter: 65536 + (randomBytes2(2).readUInt16BE(0) & 4095),
+      changeNumber: 1048576 + (randomBytes2(2).readUInt16BE(0) & 65535),
+      folders: {},
+      items: {},
+      issued: {},
+      immutable: {},
+      journal: [],
+      journalSeq: 0,
+      settings: defaultSettings(init.kind),
+      categories: defaultCategories(),
+      rules: [],
+      overrides: []
+    };
+    this.state.mailboxes[guid] = mbx;
+    this.state.byAddress[key] = guid;
+    this.provisionTree(mbx, DEFAULT_TREE, null);
+    return mbx;
+  }
+  provisionTree(mbx, t, parent) {
+    const counter = this.alloc(mbx);
+    const folderClass = t.folderClass ?? "IPF.Note";
+    mbx.folders[counter] = {
+      counter,
+      parentCounter: parent,
+      displayName: t.name,
+      wellKnownName: t.wellKnownName ?? null,
+      folderClass,
+      isHidden: t.isHidden ?? false,
+      isMailFolder: folderClass === "IPF.Note" || folderClass === "IPF",
+      distinguished: true,
+      baseSize: t.baseSize ?? 0,
+      changeNumber: this.bump(mbx),
+      createdDateTime: isoSeconds()
+    };
+    mbx.issued[counter] = "folder";
+    for (const c of t.children ?? []) {
+      this.provisionTree(mbx, c, counter);
+    }
+  }
+  /** Move a mailbox to a new primary address (the directory user's mail changed). */
+  readdressMailbox(mbx, address) {
+    delete this.state.byAddress[mbx.address.toLowerCase()];
+    mbx.address = address;
+    this.state.byAddress[address.toLowerCase()] = mbx.guid;
+  }
+  /** Remove a mailbox and the work queued for it (its directory user was deleted or lost their mail address). */
+  removeMailbox(mbx) {
+    delete this.state.mailboxes[mbx.guid];
+    if (this.state.byAddress[mbx.address.toLowerCase()] === mbx.guid) {
+      delete this.state.byAddress[mbx.address.toLowerCase()];
+    }
+    this.state.pending = this.state.pending.filter((job) => job.mailboxGuid !== mbx.guid);
+  }
+  mailboxByAddress(address) {
+    const guid = this.state.byAddress[address.toLowerCase()];
+    return guid ? this.state.mailboxes[guid] : void 0;
+  }
+  mailboxByGuid(guid) {
+    return this.state.mailboxes[guid];
+  }
+  mailboxByOid(oid) {
+    const lower = oid.toLowerCase();
+    return Object.values(this.state.mailboxes).find((m) => m.userOid.toLowerCase() === lower);
+  }
+  allMailboxes() {
+    return Object.values(this.state.mailboxes);
+  }
+  // ---------------------------------------------------------------------------
+  // Counters and identifiers
+  // ---------------------------------------------------------------------------
+  alloc(mbx) {
+    const c = mbx.nextCounter;
+    mbx.nextCounter += 1 + (randomBytes2(1)[0] & 3);
+    return c;
+  }
+  bump(mbx) {
+    mbx.changeNumber += 1 + (randomBytes2(1)[0] & 7);
+    return mbx.changeNumber;
+  }
+  folderId(mbx, f) {
+    return encodeFolderId(mbx.store, typeof f === "number" ? f : f.counter);
+  }
+  itemId(mbx, item, immutable = false) {
+    if (immutable) {
+      return encodeImmutableId(mbx.store, item.immutableCounter);
+    }
+    return encodeItemId(mbx.store, item.folderCounter, item.counter);
+  }
+  conversationId(mbx, item) {
+    return encodeConversationId(mbx.guid, Buffer.from(item.conversationGuid, "hex"));
+  }
+  changeKey(mbx, item) {
+    const b = Buffer.from(encodeChangeKey(mbx.store, item.changeNumber, "item"), "base64");
+    b.writeUInt32LE(item.changeKeyClass, 0);
+    return b.toString("base64");
+  }
+  folderChangeKey(mbx, f) {
+    return encodeChangeKey(mbx.store, f.changeNumber, "folder");
+  }
+  // ---------------------------------------------------------------------------
+  // Folder lookup
+  // ---------------------------------------------------------------------------
+  folder(mbx, counter) {
+    return mbx.folders[counter];
+  }
+  wellKnown(mbx, name) {
+    const f = Object.values(mbx.folders).find((x2) => x2.wellKnownName === name);
+    if (!f) {
+      throw new Error(`mailbox has no ${name} folder`);
+    }
+    return f;
+  }
+  root(mbx) {
+    return Object.values(mbx.folders).find((f) => f.parentCounter === null);
+  }
+  /**
+   * Resolve a folder reference from a URL or body: a well-known name
+   * (case-insensitive) or a REST id.
+   */
+  /**
+   * Resolve a folder id or well-known name. Under /mailFolders the calendar,
+   * contacts and tasks names are not mail folders: Graph answers 404
+   * ErrorItemNotFound (verified live). Contact and calendar routes pass
+   * `nonMail` to accept them.
+   */
+  resolveFolder(mbx, ref, nonMail = false) {
+    const lower = ref.toLowerCase();
+    if (ABSENT_WELL_KNOWN.has(lower)) {
+      throw Errors.folderNotFound();
+    }
+    if (MAIL_WELL_KNOWN.has(lower)) {
+      return this.wellKnown(mbx, lower);
+    }
+    if (lower === "calendar" || lower === "contacts" || lower === "tasks") {
+      if (!nonMail) {
+        throw Errors.itemNotFound();
+      }
+      return this.wellKnown(mbx, lower);
+    }
+    const decoded = decodeId(ref);
+    if (!decoded) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "immutable") {
+      throw Errors.itemIdForFolderId();
+    }
+    if (decoded.mailboxGuid !== mbx.guid) {
+      throw Errors.wrongMailbox(ref, mbx.guid);
+    }
+    if (decoded.databaseGuid !== mbx.store.databaseGuid) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "item") {
+      throw Errors.itemIdForFolderId();
+    }
+    const f = mbx.folders[decoded.folderCounter];
+    if (f && !f.isMailFolder && !nonMail) {
+      throw Errors.itemNotFound();
+    }
+    if (f) {
+      return f;
+    }
+    if (mbx.issued[decoded.folderCounter]) {
+      throw Errors.itemNotFound();
+    }
+    throw Errors.idMalformed();
+  }
+  /** Resolve a message id (regular or immutable). */
+  resolveItem(mbx, ref) {
+    const decoded = decodeId(ref);
+    if (!decoded) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "immutable") {
+      if (decoded.databaseGuid !== mbx.store.databaseGuid) {
+        const owner = this.allMailboxes().find((m) => m.store.databaseGuid === decoded.databaseGuid);
+        if (owner) {
+          throw Errors.wrongMailbox(ref, mbx.guid);
+        }
+        throw Errors.idMalformed();
+      }
+      const current = mbx.immutable[decoded.immutableCounter];
+      if (current !== void 0 && mbx.items[current]) {
+        return { item: mbx.items[current], immutable: true };
+      }
+      if (current !== void 0) {
+        throw Errors.itemNotFound();
+      }
+      throw Errors.idMalformed();
+    }
+    if (decoded.mailboxGuid !== mbx.guid) {
+      throw Errors.wrongMailbox(ref, mbx.guid);
+    }
+    if (decoded.databaseGuid !== mbx.store.databaseGuid) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "folder") {
+      throw Errors.folderIdForItemId();
+    }
+    const item = mbx.items[decoded.itemCounter];
+    if (item && item.folderCounter === decoded.folderCounter) {
+      return { item, immutable: false };
+    }
+    if (mbx.issued[decoded.itemCounter]) {
+      throw Errors.itemNotFound();
+    }
+    throw Errors.idMalformed();
+  }
+  /**
+   * Resolve an item id against any per-mailbox item map (contacts, events).
+   * Same codec and error rules as messages: wrong mailbox, malformed and
+   * deleted ids are told apart.
+   */
+  resolveIn(mbx, ref, map) {
+    const decoded = decodeId(ref);
+    if (!decoded) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "immutable") {
+      if (decoded.databaseGuid !== mbx.store.databaseGuid) {
+        const owner = this.allMailboxes().find((m) => m.store.databaseGuid === decoded.databaseGuid);
+        if (owner) {
+          throw Errors.wrongMailbox(ref, mbx.guid);
+        }
+        throw Errors.idMalformed();
+      }
+      const current = mbx.immutable[decoded.immutableCounter];
+      if (current !== void 0 && map[current]) {
+        return { item: map[current], immutable: true };
+      }
+      if (current !== void 0) {
+        throw Errors.itemNotFound();
+      }
+      throw Errors.idMalformed();
+    }
+    if (decoded.mailboxGuid !== mbx.guid) {
+      throw Errors.wrongMailbox(ref, mbx.guid);
+    }
+    if (decoded.databaseGuid !== mbx.store.databaseGuid) {
+      throw Errors.idMalformed();
+    }
+    if (decoded.kind === "folder") {
+      throw Errors.folderIdForItemId();
+    }
+    const item = map[decoded.itemCounter];
+    if (item && item.folderCounter === decoded.folderCounter) {
+      return { item, immutable: false };
+    }
+    if (mbx.issued[decoded.itemCounter]) {
+      throw Errors.itemNotFound();
+    }
+    throw Errors.idMalformed();
+  }
+  childFolders(mbx, parent, opts = {}) {
+    return Object.values(mbx.folders).filter(
+      (f) => f.parentCounter === parent.counter && (opts.includeHidden || !f.isHidden) && (!opts.mailOnly || f.isMailFolder || f.folderClass.startsWith("IPF.Note"))
+    ).sort((a, b) => a.displayName.localeCompare(b.displayName, "en", { sensitivity: "base" }));
+  }
+  descendants(mbx, f) {
+    const out = [];
+    const walk = (p) => {
+      for (const c of Object.values(mbx.folders)) {
+        if (c.parentCounter === p.counter) {
+          out.push(c);
+          walk(c);
+        }
+      }
+    };
+    walk(f);
+    return out;
+  }
+  itemsIn(mbx, folderCounter) {
+    return Object.values(mbx.items).filter((i) => i.folderCounter === folderCounter);
+  }
+  /**
+   * Messages visible through a folder: its own items, or for a search folder
+   * the live result of its query over the source folders (verified:
+   * mail.searchfolders.lifecycle).
+   */
+  folderItems(mbx, f) {
+    if (f.search) {
+      return _Exchange.searchResolver ? _Exchange.searchResolver(this, mbx, f) : [];
+    }
+    return this.itemsIn(mbx, f.counter);
+  }
+  /** Source folders a search folder looks at (with descendants when nested). */
+  searchSources(mbx, f) {
+    const out = /* @__PURE__ */ new Map();
+    for (const c of f.search?.sourceFolderCounters ?? []) {
+      const src = mbx.folders[c];
+      if (!src) {
+        continue;
+      }
+      out.set(src.counter, src);
+      if (f.search?.includeNestedFolders) {
+        for (const d of this.descendants(mbx, src)) {
+          out.set(d.counter, d);
+        }
+      }
+    }
+    return [...out.values()].filter((x2) => !x2.search);
+  }
+  /** Items visible to the mailbox-wide /messages collection (all IPM mail folders). */
+  mailboxItems(mbx) {
+    const ipm = this.wellKnown(mbx, "msgfolderroot");
+    const allowed = /* @__PURE__ */ new Set([
+      ipm.counter,
+      ...this.descendants(mbx, ipm).filter((f) => f.isMailFolder).map((f) => f.counter)
+    ]);
+    return Object.values(mbx.items).filter((i) => allowed.has(i.folderCounter));
+  }
+  otherItemsIn(mbx, folderCounter) {
+    const contacts = Object.values(mbx.contacts ?? {}).filter((x2) => x2.folderCounter === folderCounter).length;
+    const events = Object.values(mbx.events ?? {}).filter((x2) => x2.folderCounter === folderCounter).length;
+    return contacts + events;
+  }
+  counts(mbx, f) {
+    const items = this.folderItems(mbx, f);
+    return {
+      childFolderCount: Object.values(mbx.folders).filter((c) => c.parentCounter === f.counter).length,
+      unreadItemCount: items.filter((i) => !i.isRead).length,
+      // Verified live (contacts.delete-target): a deleted contact counts in Deleted Items, so
+      // contacts and calendar items stored in a mail folder count alongside its messages.
+      totalItemCount: items.length + (f.search ? 0 : this.otherItemsIn(mbx, f.counter)),
+      // Verified: search folders report sizeInBytes null.
+      sizeInBytes: f.search ? null : f.baseSize + items.reduce((n, i) => n + i.size, 0)
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Journal (drives delta queries and change notifications)
+  // ---------------------------------------------------------------------------
+  listeners = [];
+  /** Listen for journal entries; returns a function that stops listening. */
+  onChange(fn) {
+    this.listeners.push(fn);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== fn);
+    };
+  }
+  journal(mbx, kind, entity, folderCounter, counter, formerId) {
+    mbx.journalSeq += 1;
+    mbx.journal.push({
+      seq: mbx.journalSeq,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      kind,
+      entity,
+      folderCounter,
+      counter,
+      formerId
+    });
+    for (const l of this.listeners) {
+      try {
+        l(mbx, kind, entity, counter, folderCounter, formerId);
+      } catch {
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Folder operations
+  // ---------------------------------------------------------------------------
+  assertUniqueName(mbx, parent, name, except) {
+    const lower = name.toLowerCase();
+    return !Object.values(mbx.folders).some(
+      (f) => f.parentCounter === parent.counter && f.counter !== except && f.displayName.toLowerCase() === lower
+    );
+  }
+  createFolder(mbx, parent, input) {
+    if (!input.displayName.trim()) {
+      throw Errors.folderSaveProperty();
+    }
+    if (!this.assertUniqueName(mbx, parent, input.displayName)) {
+      throw Errors.folderExists(input.displayName);
+    }
+    const counter = this.alloc(mbx);
+    const f = {
+      counter,
+      parentCounter: parent.counter,
+      displayName: input.displayName,
+      wellKnownName: null,
+      folderClass: input.folderClass ?? "IPF.Note",
+      isHidden: input.isHidden ?? false,
+      isMailFolder: (input.folderClass ?? "IPF.Note").startsWith("IPF.Note"),
+      distinguished: false,
+      baseSize: 0,
+      changeNumber: this.bump(mbx),
+      createdDateTime: isoSeconds(),
+      ...input.search ? { search: input.search } : {}
+    };
+    mbx.folders[counter] = f;
+    mbx.issued[counter] = "folder";
+    this.journal(mbx, "created", "folder", parent.counter, counter);
+    return f;
+  }
+  updateFolder(mbx, f, patch) {
+    if (patch.displayName !== void 0) {
+      if (f.distinguished) {
+        throw Errors.folderSaveProperty();
+      }
+      if (!patch.displayName.trim()) {
+        throw Errors.folderSaveProperty();
+      }
+      const parent = f.parentCounter === null ? null : mbx.folders[f.parentCounter];
+      if (parent && !this.assertUniqueName(mbx, parent, patch.displayName, f.counter)) {
+        throw Errors.folderSaveProperty();
+      }
+      f.displayName = patch.displayName;
+    }
+    if (patch.isHidden !== void 0) {
+      f.isHidden = patch.isHidden;
+    }
+    f.changeNumber = this.bump(mbx);
+    this.journal(mbx, "updated", "folder", f.parentCounter ?? f.counter, f.counter);
+    return f;
+  }
+  deleteFolder(mbx, f) {
+    if (f.distinguished) {
+      throw Errors.deleteDistinguished();
+    }
+    const formerParent = f.parentCounter ?? f.counter;
+    for (const d of [f, ...this.descendants(mbx, f)]) {
+      for (const item of this.itemsIn(mbx, d.counter)) {
+        this.removeItem(mbx, item, "deleted");
+      }
+      for (const [entity, map] of [
+        ["contact", mbx.contacts],
+        ["event", mbx.events]
+      ]) {
+        for (const x2 of Object.values(map ?? {})) {
+          if (x2.folderCounter !== d.counter) {
+            continue;
+          }
+          delete map[x2.counter];
+          mbx.immutable[x2.immutableCounter] = -1;
+          this.journal(mbx, "deleted", entity, d.counter, x2.counter, encodeItemId(mbx.store, d.counter, x2.counter));
+        }
+      }
+      delete mbx.folders[d.counter];
+    }
+    this.journal(mbx, "deleted", "folder", formerParent, f.counter, this.folderId(mbx, f));
+  }
+  moveFolder(mbx, f, dest) {
+    if (f.distinguished) {
+      throw Errors.moveCopyFailed();
+    }
+    if (dest.counter === f.counter || this.descendants(mbx, f).some((d) => d.counter === dest.counter)) {
+      throw Errors.moveCopyFailed();
+    }
+    if (!this.assertUniqueName(mbx, dest, f.displayName, f.counter)) {
+      throw Errors.folderExists(f.displayName);
+    }
+    const from = f.parentCounter;
+    f.parentCounter = dest.counter;
+    f.changeNumber = this.bump(mbx);
+    this.journal(mbx, "deleted", "folder", from, f.counter, this.folderId(mbx, f));
+    this.journal(mbx, "created", "folder", dest.counter, f.counter);
+    return f;
+  }
+  copyFolder(mbx, f, dest) {
+    if (f.distinguished) {
+      throw Errors.moveCopyFailed();
+    }
+    if (dest.counter === f.counter || this.descendants(mbx, f).some((d) => d.counter === dest.counter)) {
+      throw Errors.moveCopyFailed();
+    }
+    if (!this.assertUniqueName(mbx, dest, f.displayName)) {
+      throw Errors.folderExists(f.displayName);
+    }
+    const copyTree = (src, parent) => {
+      const counter = this.alloc(mbx);
+      const c = {
+        ...src,
+        counter,
+        parentCounter: parent.counter,
+        distinguished: false,
+        wellKnownName: null,
+        changeNumber: this.bump(mbx)
+      };
+      mbx.folders[counter] = c;
+      mbx.issued[counter] = "folder";
+      for (const item of this.itemsIn(mbx, src.counter)) {
+        this.copyItem(mbx, item, c);
+      }
+      for (const child of Object.values(mbx.folders).filter(
+        (x2) => x2.parentCounter === src.counter && x2.counter !== counter
+      )) {
+        copyTree(child, c);
+      }
+      return c;
+    };
+    const copy = copyTree(f, dest);
+    this.journal(mbx, "created", "folder", dest.counter, copy.counter);
+    return copy;
+  }
+  // ---------------------------------------------------------------------------
+  // Items
+  // ---------------------------------------------------------------------------
+  /** Directory display name for an address inside the tenant. */
+  directoryName(address) {
+    const mbx = this.mailboxByAddress(address);
+    return mbx ? mbx.displayName : null;
+  }
+  /**
+   * Normalize a recipient the way the store does: tenant addresses take the
+   * directory display name; external addresses keep the supplied name or
+   * fall back to the address.
+   */
+  resolveRecipient(r) {
+    const address = r.emailAddress?.address ?? "";
+    const dir = address ? this.directoryName(address) : null;
+    const name = dir ?? (r.emailAddress?.name || address);
+    return { emailAddress: { name, address } };
+  }
+  newMessage(mbx, folder, fields) {
+    const now = isoSeconds();
+    const counter = this.alloc(mbx);
+    const conversationGuid = fields.conversationGuid ?? guidHex();
+    const item = {
+      counter,
+      immutableCounter: counter,
+      folderCounter: folder.counter,
+      state: "draft",
+      itemClass: "IPM.Note",
+      createdDateTime: now,
+      lastModifiedDateTime: now,
+      receivedDateTime: now,
+      sentDateTime: now,
+      changeNumber: this.bump(mbx),
+      changeKeyClass: 9,
+      categories: [],
+      internetMessageId: "",
+      subject: "",
+      body: { contentType: "text", content: "" },
+      uniqueBody: null,
+      importance: "normal",
+      conversationGuid,
+      conversationIndex: "",
+      isDeliveryReceiptRequested: false,
+      isReadReceiptRequested: false,
+      isRead: true,
+      inferenceClassification: "focused",
+      sender: null,
+      from: null,
+      toRecipients: [],
+      ccRecipients: [],
+      bccRecipients: [],
+      replyTo: [],
+      flag: { flagStatus: "notFlagged" },
+      internetMessageHeaders: null,
+      attachments: [],
+      inReplyTo: null,
+      references: null,
+      readReceiptSent: false,
+      singleValueExtendedProperties: [],
+      multiValueExtendedProperties: [],
+      extensions: [],
+      size: 0,
+      ...fields
+    };
+    item.counter = counter;
+    item.immutableCounter = counter;
+    item.folderCounter = folder.counter;
+    item.changeNumber = this.bump(mbx);
+    this.recomputeSize(item);
+    mbx.items[counter] = item;
+    mbx.issued[counter] = "item";
+    mbx.immutable[counter] = counter;
+    this.journal(mbx, "created", "message", folder.counter, counter);
+    return item;
+  }
+  recomputeSize(item) {
+    const recips = [...item.toRecipients, ...item.ccRecipients, ...item.bccRecipients, ...item.replyTo];
+    item.size = 1800 + Buffer.byteLength(item.subject) * 2 + Buffer.byteLength(item.body.content) + recips.reduce((n, r) => n + 40 + r.emailAddress.address.length + r.emailAddress.name.length, 0) + item.attachments.reduce((n, a) => n + a.size, 0);
+  }
+  /** Record a content change: new change number, lastModified, journal. */
+  touch(mbx, item, kind = "content") {
+    if (kind === "content") {
+      item.changeNumber = this.bump(mbx);
+      item.lastModifiedDateTime = isoSeconds();
+      this.recomputeSize(item);
+      this.journal(mbx, "updated", "message", item.folderCounter, item.counter);
+    } else {
+      this.journal(mbx, "read", "message", item.folderCounter, item.counter);
+    }
+  }
+  moveItem(mbx, item, dest) {
+    if (dest.counter === item.folderCounter) {
+      return item;
+    }
+    const formerId = this.itemId(mbx, item);
+    const from = item.folderCounter;
+    delete mbx.items[item.counter];
+    this.journal(mbx, "deleted", "message", from, item.counter, formerId);
+    const counter = this.alloc(mbx);
+    item.counter = counter;
+    item.folderCounter = dest.counter;
+    item.changeNumber = this.bump(mbx);
+    item.lastModifiedDateTime = isoSeconds();
+    mbx.items[counter] = item;
+    mbx.issued[counter] = "item";
+    mbx.immutable[item.immutableCounter] = counter;
+    this.journal(mbx, "created", "message", dest.counter, counter);
+    return item;
+  }
+  copyItem(mbx, item, dest, targetMbx = mbx) {
+    const clone = JSON.parse(JSON.stringify(item));
+    const copy = this.newMessage(targetMbx, dest, {
+      ...clone,
+      createdDateTime: isoSeconds(),
+      lastModifiedDateTime: isoSeconds(),
+      attachments: clone.attachments.map((a) => ({ ...a, counter: this.alloc(targetMbx) }))
+    });
+    return copy;
+  }
+  /** Remove an item from its folder (journaled). */
+  removeItem(mbx, item, kind) {
+    const formerId = this.itemId(mbx, item);
+    delete mbx.items[item.counter];
+    this.journal(mbx, kind, "message", item.folderCounter, item.counter, formerId);
+  }
+  /** DELETE: soft delete into Recoverable Items/Deletions. */
+  deleteItem(mbx, item) {
+    const deletions = this.wellKnown(mbx, "recoverableitemsdeletions");
+    if (item.folderCounter === deletions.counter) {
+      this.purgeItem(mbx, item);
+      return;
+    }
+    this.moveItem(mbx, item, deletions);
+  }
+  /** permanentDelete: remove entirely (ids now answer 404). */
+  purgeItem(mbx, item) {
+    this.removeItem(mbx, item, "deleted");
+    delete mbx.immutable[item.immutableCounter];
+    mbx.immutable[item.immutableCounter] = -1;
+  }
+  findByInternetMessageId(mbx, imid) {
+    return Object.values(mbx.items).filter((i) => i.internetMessageId === imid);
+  }
+};
+function defaultCategories() {
+  const presets = [
+    ["Red category", "preset0"],
+    ["Orange category", "preset1"],
+    ["Yellow category", "preset3"],
+    ["Green category", "preset4"],
+    ["Blue category", "preset7"],
+    ["Purple category", "preset8"]
+  ];
+  return presets.map(([displayName, color]) => ({ id: randomUUID(), displayName, color }));
+}
+var instances = /* @__PURE__ */ new WeakMap();
+function getExchange(store) {
+  let ex = instances.get(store);
+  if (!ex) {
+    ex = new Exchange(store);
+    instances.set(store, ex);
+  }
+  return ex;
+}
+
+// src/graph/exchange/calendar.ts
+var ISO_DATE_PARTS = /^(\d{4})-(\d{2})-(\d{2})$/;
+var DAY = 864e5;
+var ZERO_TIME = "0001-01-01T00:00:00Z";
+var GOID_PREFIX = "040000008200E00074C5B7101A82E008";
+function newGoid(at = Date.now()) {
+  const filetime = (BigInt(at) * 10000n + 116444736000000000n).toString(16).padStart(16, "0");
+  const le = filetime.match(/../g).reverse().join("");
+  return `${GOID_PREFIX}00000000${le}0000000000000000${"10000000"}${randomBytes3(16).toString("hex")}`.toUpperCase();
+}
+function occurrenceGoid(uid, dateMs) {
+  const d = new Date(dateMs);
+  const hex = d.getUTCFullYear().toString(16).padStart(4, "0") + (d.getUTCMonth() + 1).toString(16).padStart(2, "0") + d.getUTCDate().toString(16).padStart(2, "0");
+  return `${uid.slice(0, 32)}${hex.toUpperCase()}${uid.slice(40)}`;
+}
+var GROUP_CLASSES = {
+  my: "0006f0b7-0000-0000-c000-000000000046",
+  other: "0006f0b8-0000-0000-c000-000000000046",
+  people: "0006f0b9-0000-0000-c000-000000000046"
+};
+function isCalendarFolder(f) {
+  return f.folderClass.startsWith("IPF.Appointment");
+}
+function defaultCalendar(ex, mbx) {
+  return ex.wellKnown(mbx, "calendar");
+}
+function calendarGroups(ex, mbx) {
+  if (!mbx.calendarGroups) {
+    const root = ex.wellKnown(mbx, "msgfolderroot");
+    const make = (name, classId, calendars) => {
+      const counter = ex.alloc(mbx);
+      mbx.issued[counter] = "item";
+      return {
+        id: encodeItemId(mbx.store, root.counter, counter),
+        name,
+        classId,
+        changeNumber: ex.bump(mbx),
+        calendars
+      };
+    };
+    mbx.calendarGroups = [
+      make("My Calendars", GROUP_CLASSES.my, [defaultCalendar(ex, mbx).counter]),
+      make("Other Calendars", GROUP_CLASSES.other, []),
+      ...mbx.kind === "user" ? [make("People's Calendars", GROUP_CLASSES.people, [])] : []
+    ];
+  }
+  return mbx.calendarGroups;
+}
+function groupOfCalendar(ex, mbx, f) {
+  const groups = calendarGroups(ex, mbx);
+  return groups.find((g2) => g2.calendars.includes(f.counter)) ?? groups[0];
+}
+function calendarFolders(ex, mbx) {
+  const def = defaultCalendar(ex, mbx);
+  const all = ex.descendants(mbx, ex.wellKnown(mbx, "msgfolderroot")).filter((f) => isCalendarFolder(f) && f.counter !== def.counter && !f.isHidden);
+  return [def, ...all];
+}
+var NAV_FOLDER = 1;
+function calendarId(ex, mbx, f) {
+  const m = calendarMeta(mbx, f);
+  if (m.navCounter === void 0) {
+    m.navCounter = ex.alloc(mbx);
+  }
+  return encodeItemId(mbx.store, NAV_FOLDER, m.navCounter);
+}
+function calendarByNavId(mbx, id) {
+  const d = decodeId(id);
+  if (d?.kind !== "item" || d.folderCounter !== NAV_FOLDER) {
+    return null;
+  }
+  for (const [counter, m] of Object.entries(mbx.calendarMeta ?? {})) {
+    if (m.navCounter === d.itemCounter) {
+      return Number(counter);
+    }
+  }
+  return null;
+}
+function calendarMeta(mbx, f) {
+  if (!mbx.calendarMeta) {
+    mbx.calendarMeta = {};
+  }
+  mbx.calendarMeta[f.counter] ??= { color: "auto", hexColor: "", isDefault: false };
+  return mbx.calendarMeta[f.counter];
+}
+var CALENDAR_COLORS = {
+  auto: "",
+  lightBlue: "#a6d1f5",
+  lightGreen: "#87d28e",
+  lightOrange: "#fcab73",
+  lightGray: "#c0c0c0",
+  lightYellow: "#f4d07a",
+  lightTeal: "#5fd2c3",
+  lightPink: "#f8a9ce",
+  lightBrown: "#e2b38a",
+  lightRed: "#f88a8b",
+  maxColor: ""
+};
+function eventsOf(mbx) {
+  if (!mbx.events) {
+    mbx.events = {};
+  }
+  return mbx.events;
+}
+function eventChangeKey(mbx, e) {
+  return encodeChangeKey(mbx.store, e.changeNumber, "event");
+}
+function eventLongChangeKey(mbx, e) {
+  return encodeChangeKey(mbx.store, e.changeNumber, "eventLong");
+}
+function eventId(mbx, e, immutable = false) {
+  if (e.type === "exception" && e.seriesMasterCounter !== null && e.originalStartMs !== null) {
+    const master = eventsOf(mbx)[e.seriesMasterCounter];
+    if (master) {
+      return occurrenceId(mbx, master, localDate(master, e.originalStartMs));
+    }
+  }
+  return immutable ? encodeImmutableId(mbx.store, e.immutableCounter) : encodeItemId(mbx.store, e.folderCounter, e.counter);
+}
+function occurrenceId(mbx, master, dateMs) {
+  return encodeOccurrenceId(mbx.store, master.folderCounter, master.counter, dateMs);
+}
+function occurrenceKey(mbx, master, dateMs) {
+  return `OID.${eventId(mbx, master)}.${new Date(dateMs).toISOString().slice(0, 10)}`;
+}
+function eventsIn(mbx, folderCounter) {
+  return Object.values(eventsOf(mbx)).filter((e) => e.folderCounter === folderCounter);
+}
+function defaultEvent(organizer) {
+  const uid = newGoid();
+  return {
+    categories: [],
+    extensions: [],
+    singleValueExtendedProperties: [],
+    multiValueExtendedProperties: [],
+    uid,
+    iCalUId: uid,
+    type: "singleInstance",
+    seriesMasterCounter: null,
+    originalStartMs: null,
+    subject: "",
+    // Verified: an event created without a body holds empty text.
+    body: { contentType: "text", content: "" },
+    importance: "normal",
+    sensitivity: "normal",
+    showAs: "busy",
+    isAllDay: false,
+    isCancelled: false,
+    isDraft: false,
+    startMs: 0,
+    endMs: 0,
+    originalStartTimeZone: "UTC",
+    originalEndTimeZone: "UTC",
+    location: emptyLocation(),
+    locations: [],
+    attendees: [],
+    organizer: { emailAddress: { ...organizer } },
+    isOrganizer: true,
+    responseStatus: { response: "organizer", time: ZERO_TIME },
+    responseRequested: true,
+    allowNewTimeProposals: true,
+    hideAttendees: false,
+    isReminderOn: true,
+    reminderMinutesBeforeStart: 15,
+    reminderDismissedMs: null,
+    reminderSnoozedUntilMs: null,
+    isOnlineMeeting: false,
+    onlineMeetingProvider: "unknown",
+    transactionId: null,
+    recurrence: null,
+    cancelledOccurrences: [],
+    attachments: [],
+    sequence: 0
+  };
+}
+function emptyLocation() {
+  return { displayName: "", locationType: "default", uniqueIdType: "unknown", address: {}, coordinates: {} };
+}
+function newEvent(ex, mbx, folder, init) {
+  const now = createdStamp();
+  const counter = ex.alloc(mbx);
+  const owner = { name: mbx.displayName, address: mbx.address };
+  const e = {
+    ...defaultEvent(owner),
+    ...init,
+    counter,
+    immutableCounter: counter,
+    folderCounter: folder.counter,
+    changeNumber: ex.bump(mbx),
+    createdDateTime: now,
+    lastModifiedDateTime: now
+  };
+  eventsOf(mbx)[counter] = e;
+  mbx.issued[counter] = "item";
+  mbx.immutable[counter] = counter;
+  ex.journal(mbx, "created", "event", folder.counter, counter);
+  return e;
+}
+function createdStamp(d = /* @__PURE__ */ new Date()) {
+  return `${d.toISOString().slice(0, 23)}0000Z`;
+}
+function touchEvent(ex, mbx, e) {
+  e.changeNumber = ex.bump(mbx);
+  e.lastModifiedDateTime = createdStamp();
+  ex.journal(mbx, "updated", "event", e.folderCounter, e.counter);
+}
+function moveEvent(ex, mbx, e, dest) {
+  if (dest.counter === e.folderCounter) {
+    return e;
+  }
+  const map = eventsOf(mbx);
+  const formerId = eventId(mbx, e);
+  delete map[e.counter];
+  ex.journal(mbx, "deleted", "event", e.folderCounter, e.counter, formerId);
+  const counter = ex.alloc(mbx);
+  e.counter = counter;
+  e.folderCounter = dest.counter;
+  e.changeNumber = ex.bump(mbx);
+  e.lastModifiedDateTime = createdStamp();
+  map[counter] = e;
+  mbx.issued[counter] = "item";
+  mbx.immutable[e.immutableCounter] = counter;
+  ex.journal(mbx, "created", "event", dest.counter, counter);
+  return e;
+}
+function purgeEvent(ex, mbx, e) {
+  const map = eventsOf(mbx);
+  for (const x2 of exceptionsOf(mbx, e)) {
+    delete map[x2.counter];
+    mbx.immutable[x2.immutableCounter] = -1;
+  }
+  const formerId = eventId(mbx, e);
+  delete map[e.counter];
+  mbx.immutable[e.immutableCounter] = -1;
+  ex.journal(mbx, "deleted", "event", e.folderCounter, e.counter, formerId);
+}
+function deleteEvent(ex, mbx, e, to = "recoverableitemsdeletions") {
+  const dest = ex.wellKnown(mbx, to);
+  if (e.folderCounter === dest.counter) {
+    purgeEvent(ex, mbx, e);
+    return;
+  }
+  const exceptions = exceptionsOf(mbx, e);
+  moveEvent(ex, mbx, e, dest);
+  for (const x2 of exceptions) {
+    x2.seriesMasterCounter = e.counter;
+  }
+}
+function exceptionsOf(mbx, master) {
+  return Object.values(eventsOf(mbx)).filter((x2) => x2.type === "exception" && x2.seriesMasterCounter === master.counter);
+}
+var WEEKDAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var INDEX = ["first", "second", "third", "fourth", "last"];
+function dateOnly(s) {
+  const m = ISO_DATE_PARTS.exec(s);
+  if (!m) {
+    return null;
+  }
+  const ms = Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  return Number.isNaN(ms) ? null : ms;
+}
+function formatDate(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+function localDateIn(iana, utcMs) {
+  const wall = utcToWall(utcMs, iana);
+  return wall - (wall % DAY + DAY) % DAY;
+}
+function seriesZone(master) {
+  const name = master.recurrence?.range.recurrenceTimeZone || master.originalStartTimeZone || "UTC";
+  return resolveZone(name)?.iana ?? "UTC";
+}
+function localDate(master, utcMs) {
+  return localDateIn(seriesZone(master), utcMs);
+}
+function daysInMonth(y, m) {
+  return new Date(Date.UTC(y, m + 1, 0)).getUTCDate();
+}
+function relativeDay(y, m, days, index) {
+  const matches = [];
+  for (let d = 1; d <= daysInMonth(y, m); d += 1) {
+    if (days.includes(new Date(Date.UTC(y, m, d)).getUTCDay())) {
+      matches.push(d);
+    }
+  }
+  if (!matches.length) {
+    return null;
+  }
+  const i = INDEX.indexOf(index);
+  if (index === "last") {
+    return matches.at(-1);
+  }
+  return matches[i] ?? null;
+}
+function* patternDates(r) {
+  const start = dateOnly(r.range.startDate);
+  const p = r.pattern;
+  const interval = Math.max(1, p.interval);
+  const days = p.daysOfWeek.map((d) => WEEKDAYS.indexOf(d.toLowerCase())).filter((d) => d >= 0);
+  const s = new Date(start);
+  switch (p.type) {
+    case "daily":
+      for (let k = 0; ; k += 1) {
+        yield start + k * interval * DAY;
+      }
+    case "weekly": {
+      const first = WEEKDAYS.indexOf((p.firstDayOfWeek || "sunday").toLowerCase());
+      const offset = (s.getUTCDay() - first + 7) % 7;
+      const weekStart = start - offset * DAY;
+      const order = days.map((d) => (d - first + 7) % 7).sort((a, b) => a - b);
+      if (!order.length) {
+        return;
+      }
+      for (let w = 0; ; w += 1) {
+        for (const o of order) {
+          const d = weekStart + (w * interval * 7 + o) * DAY;
+          if (d >= start) {
+            yield d;
+          }
+        }
+      }
+    }
+    case "absoluteMonthly":
+    case "relativeMonthly":
+    case "absoluteYearly":
+    case "relativeYearly": {
+      const yearly = p.type.endsWith("Yearly");
+      for (let k = 0; ; k += 1) {
+        let y;
+        let m;
+        if (yearly) {
+          y = s.getUTCFullYear() + k * interval;
+          m = p.month - 1;
+        } else {
+          const total = s.getUTCMonth() + k * interval;
+          y = s.getUTCFullYear() + Math.floor(total / 12);
+          m = total % 12;
+        }
+        let day;
+        if (p.type.startsWith("absolute")) {
+          day = Math.min(p.dayOfMonth, daysInMonth(y, m));
+        } else {
+          day = relativeDay(y, m, days, p.index);
+        }
+        if (day === null) {
+          continue;
+        }
+        const d = Date.UTC(y, m, day);
+        if (d >= start) {
+          yield d;
+        }
+        if (k > 2e4) {
+          return;
+        }
+      }
+    }
+    default:
+      return;
+  }
+}
+function expandSeries(master, fromMs, toMs, limit = 5e3) {
+  const r = master.recurrence;
+  if (!r) {
+    return [];
+  }
+  const iana = seriesZone(master);
+  const startWall = utcToWall(master.startMs, iana);
+  const timeOfDay = (startWall % DAY + DAY) % DAY;
+  const duration = master.endMs - master.startMs;
+  const end = r.range.type === "endDate" ? dateOnly(r.range.endDate) : null;
+  const out = [];
+  let n = 0;
+  let guard = 0;
+  for (const d of patternDates(r)) {
+    guard += 1;
+    if (guard > 2e5) {
+      break;
+    }
+    if (end !== null && d > end) {
+      break;
+    }
+    if (r.range.type === "numbered" && n >= r.range.numberOfOccurrences) {
+      break;
+    }
+    n += 1;
+    const startMs = wallToUtc(d + timeOfDay, iana);
+    if (startMs >= toMs) {
+      break;
+    }
+    if (master.cancelledOccurrences.includes(d)) {
+      continue;
+    }
+    const endMs = startMs + duration;
+    if (endMs > fromMs || endMs === startMs && startMs >= fromMs) {
+      out.push({ dateMs: d, startMs, endMs });
+    }
+    if (out.length >= limit) {
+      break;
+    }
+  }
+  return out;
+}
+function occurrenceOn(master, dateMs) {
+  const all = expandSeries(master, dateMs - 2 * DAY, dateMs + 3 * DAY);
+  return all.find((o) => o.dateMs === dateMs) ?? null;
+}
+function firstSeriesDate(r) {
+  for (const d of patternDates(r)) {
+    return d;
+  }
+  return null;
+}
+function occurrenceView(master, o) {
+  return {
+    ...master,
+    type: "occurrence",
+    seriesMasterCounter: master.counter,
+    originalStartMs: o.startMs,
+    startMs: o.startMs,
+    endMs: o.endMs,
+    recurrence: null,
+    iCalUId: occurrenceGoid(master.uid, o.dateMs)
+  };
+}
+
+// src/graph/http.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var PREFERENCE_PAIR = /^([\w.-]+)\s*=\s*"?([^"]*)"?$/;
+var ODATA_JSON = "application/json; odata.metadata=minimal; odata.streaming=true; IEEE754Compatible=false; charset=utf-8";
+var OUTLOOK_JSON = "application/json;odata.metadata=minimal;odata.streaming=true;IEEE754Compatible=false;charset=utf-8";
+function json(status, body, headers = {}) {
+  return { status, headers: { "Content-Type": ODATA_JSON, ...headers }, body };
+}
+function noContent(status = 204, headers = {}) {
+  return { status, headers, body: null };
+}
+function errorResponse(err, req) {
+  const r = renderError(err, req);
+  let contentType = "application/json";
+  if (err.layer === "exchange") {
+    contentType = ODATA_JSON;
+  } else if (err.layer === "sharepoint") {
+    contentType = "application/json; charset=utf-8";
+  }
+  return { status: r.status, headers: { "Content-Type": contentType, ...r.headers }, body: r.body };
+}
+function newRequestId() {
+  return randomUUID2();
+}
+function parseJsonBody(req, opts = {}) {
+  const text = req.bodyText;
+  if (!text?.trim()) {
+    if (opts.allowEmpty) {
+      return {};
+    }
+    return {};
+  }
+  try {
+    const v = JSON.parse(text);
+    if (v === null || typeof v !== "object" || Array.isArray(v)) {
+      throw Errors.unreadableJson();
+    }
+    return v;
+  } catch (e) {
+    if (e instanceof GraphError) {
+      throw e;
+    }
+    throw Errors.unreadableJson();
+  }
+}
+function parsePrefer(header2) {
+  const out = {
+    bodyType: null,
+    immutableIds: false,
+    maxPageSize: null,
+    applied: [],
+    returnMinimal: false,
+    trackChangesOnly: false,
+    timeZone: null
+  };
+  if (!header2) {
+    return out;
+  }
+  for (const part of header2.split(",")) {
+    const p = part.trim();
+    const m = PREFERENCE_PAIR.exec(p);
+    if (!m) {
+      if (p.toLowerCase() === "return=minimal") {
+        out.returnMinimal = true;
+      }
+      continue;
+    }
+    const key = m[1].toLowerCase();
+    const [, , value] = m;
+    if (key === "outlook.body-content-type") {
+      const v = value.toLowerCase();
+      if (v !== "text" && v !== "html") {
+        throw Errors.bodyContentTypeNotSupported();
+      }
+      out.bodyType = v;
+      out.applied.push(`outlook.body-content-type="${v}"`);
+    } else if (key === "idtype") {
+      if (value.toLowerCase() === "immutableid") {
+        out.immutableIds = true;
+        out.applied.push("IdType=ImmutableId");
+      }
+    } else if (key === "odata.maxpagesize") {
+      const n = Number.parseInt(value, 10);
+      if (Number.isFinite(n) && n > 0) {
+        out.maxPageSize = n;
+      }
+    } else if (key === "return") {
+      out.returnMinimal = value.toLowerCase() === "minimal";
+    } else if (key === "outlook.timezone") {
+      out.timeZone = value;
+    } else if (key === "odata.track-changes") {
+      out.trackChangesOnly = true;
+    }
+  }
+  return out;
+}
+function contextUserKey(key) {
+  return encodeURIComponent(key).replace(/%2B/gi, "+");
+}
+
+// src/graph/exchange/bodies.ts
+var CID_SCHEME = /^cid:/i;
+var HTML_BODY_CONTENT = /<body[^>]*>([\s\S]*?)<\/body>/i;
+var HTML_DOCTYPE = /<!DOCTYPE[^>]*>/i;
+var HTML_HEAD_ELEMENT = /<head[\s\S]*?<\/head>/i;
+var TRAILING_WHITESPACE_CHAR = /\s$/;
+var LEADING_SPACES = /^[ \t]+/;
+var MAILTO_SCHEME = /^mailto:/i;
+var TRAILING_SPACES = /[ \t]+$/;
+var LEADING_CRLFS = /^(\r\n)+/;
+var TRAILING_CRLFS = /(\r\n)+$/;
+var BLOCK_ELEMENT_START = /^<(div|p|ul|ol|table|blockquote|pre|h[1-6])\b/i;
+var TRAILING_WHITESPACE = /\s+$/;
+var ATTENDEE_EMPTY_BODY = '<html>\r\n<head>\r\n<meta http-equiv="Content-Type" content="text/html; charset=utf-8">\r\n<meta name="Generator" content="Microsoft Exchange Server">\r\n<!-- converted from rtf -->\r\n<style><!-- .EmailQuote { margin-left: 1pt; padding-left: 4pt; border-left: #800000 2px solid; } --></style>\r\n</head>\r\n<body>\r\n<font face="Times New Roman" size="3"><span style="font-size:12pt;"><a name="BM_BEGIN"></a></span></font>\r\n</body>\r\n</html>\r\n';
+var TEXT_QUOTE_HEAD = '<html><head>\r\n<meta http-equiv="Content-Type" content="text/html; charset=utf-8"><meta name="Generator" content="Microsoft Exchange Server"><style>\r\n<!--\r\n.EmailQuote\r\n	{margin-left:1pt;\r\n	padding-left:4pt;\r\n	border-left:#800000 2px solid}\r\n-->\r\n</style></head>';
+var HTML_HEAD = '<html><head>\r\n<meta http-equiv="Content-Type" content="text/html; charset=utf-8"></head>';
+var PREVIEW_LIMIT = 255;
+var BLOCK_PARAGRAPH = /* @__PURE__ */ new Set(["p", "ul", "ol", "table", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote", "pre"]);
+var BLOCK_LINE = /* @__PURE__ */ new Set([
+  "div",
+  "li",
+  "tr",
+  "hr",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "dl",
+  "dt",
+  "dd",
+  "center",
+  "form"
+]);
+var VOID = /* @__PURE__ */ new Set([
+  "br",
+  "hr",
+  "img",
+  "meta",
+  "link",
+  "input",
+  "col",
+  "area",
+  "base",
+  "wbr",
+  "source",
+  "track",
+  "embed",
+  "param"
+]);
+var SKIP_CONTENT = /* @__PURE__ */ new Set(["head", "style", "script", "title"]);
+function tokenize(html) {
+  const out = [];
+  const re = /<!--[\s\S]*?-->|<!\w[^>]*>|<\/?([a-zA-Z][a-zA-Z0-9:-]*)((?:\s+[^\s"'>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'>]+))?)*)\s*(\/?)>/g;
+  let last = 0;
+  for (let m = re.exec(html); m; m = re.exec(html)) {
+    if (m.index > last) {
+      out.push({ type: "text", raw: html.slice(last, m.index) });
+    }
+    const [raw] = m;
+    if (raw.startsWith("<!--")) {
+      out.push({ type: "comment", raw });
+    } else if (raw.startsWith("<!")) {
+      out.push({ type: "doctype", raw });
+    } else {
+      const name = m[1].toLowerCase();
+      const attrs = [];
+      const attrRe = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+      for (let a = attrRe.exec(m[2] ?? ""); a; a = attrRe.exec(m[2] ?? "")) {
+        const value = a[2] ?? a[3] ?? a[4];
+        attrs.push([a[1], value === void 0 ? null : value]);
+      }
+      out.push({ type: raw.startsWith("</") ? "close" : "open", name, attrs, selfClosing: m[3] === "/", raw });
+    }
+    last = re.lastIndex;
+  }
+  if (last < html.length) {
+    out.push({ type: "text", raw: html.slice(last) });
+  }
+  return out;
+}
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0",
+  copy: "\xA9",
+  reg: "\xAE",
+  hellip: "\u2026",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  euro: "\u20AC",
+  trade: "\u2122",
+  bull: "\u2022"
+};
+function decodeEntities(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, e) => {
+    if (e[0] === "#") {
+      const code = e[1] === "x" || e[1] === "X" ? Number.parseInt(e.slice(2), 16) : Number.parseInt(e.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+    }
+    return NAMED_ENTITIES[e.toLowerCase()] ?? whole;
+  });
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+  return s.replace(/&(?![a-z#0-9]+;)/gi, "&amp;").replace(/"/g, "&quot;");
+}
+function serializeTag(t) {
+  if (t.type !== "open" && t.type !== "close") {
+    return t.raw;
+  }
+  if (t.type === "close") {
+    return `</${t.name}>`;
+  }
+  const attrs = (t.attrs ?? []).map(([k, v]) => v === null ? ` ${k}` : ` ${k}="${escapeAttr(v)}"`).join("");
+  return `<${t.name}${attrs}${t.selfClosing && !VOID.has(t.name) ? " /" : ""}>`;
+}
+function normalizeInnerHtml(inner) {
+  return tokenize(inner).map((t) => {
+    if (t.type !== "open") {
+      return t.raw;
+    }
+    if (t.name === "img") {
+      const src = t.attrs?.find(([k]) => k.toLowerCase() === "src")?.[1] ?? "";
+      if (CID_SCHEME.test(src) && !t.attrs.some(([k]) => k.toLowerCase() === "data-outlook-trace")) {
+        const idx = t.attrs.findIndex(([k]) => k.toLowerCase() === "src");
+        t.attrs.splice(idx, 0, ["data-outlook-trace", "F:0|T:1"]);
+      }
+    }
+    return serializeTag(t);
+  }).join("");
+}
+function bodyInner(html) {
+  const m = HTML_BODY_CONTENT.exec(html);
+  if (m) {
+    return m[1];
+  }
+  return html.replace(HTML_DOCTYPE, "").replace(/<\/?html[^>]*>/gi, "").replace(HTML_HEAD_ELEMENT, "");
+}
+function endsWithInlineContent(inner) {
+  const tokens = tokenize(inner).filter((t) => !(t.type === "text" && t.raw.trim() === ""));
+  const last = tokens.at(-1);
+  if (!last) {
+    return false;
+  }
+  if (last.type === "text") {
+    return true;
+  }
+  if (last.type === "close") {
+    return !(BLOCK_PARAGRAPH.has(last.name) || BLOCK_LINE.has(last.name));
+  }
+  if (last.type === "open") {
+    return last.name === "br" || last.name === "img";
+  }
+  return false;
+}
+function storeHtml(content) {
+  let inner = normalizeInnerHtml(bodyInner(content));
+  if (endsWithInlineContent(inner) && !TRAILING_WHITESPACE_CHAR.test(inner)) {
+    inner += " ";
+  }
+  return `${HTML_HEAD}<body>${inner}</body></html>`;
+}
+function storeBody(input) {
+  if (!input) {
+    return { contentType: "text", content: "" };
+  }
+  const type = (input.contentType ?? "text").toLowerCase() === "html" ? "html" : "text";
+  const content = input.content ?? "";
+  if (type === "html") {
+    return { contentType: "html", content: storeHtml(content) };
+  }
+  return { contentType: "text", content };
+}
+function htmlToText(html, opts = { links: true }) {
+  const tokens = tokenize(bodyInner(html));
+  let out = "";
+  let pending = 0;
+  let pendingFromBr = false;
+  let skipDepth = 0;
+  const anchorStack = [];
+  let preDepth = 0;
+  let atLineStart = true;
+  const requestBreak = (n) => {
+    if (out.length === 0) {
+      return;
+    }
+    if (pendingFromBr && pending > 0) {
+      pending = Math.max(pending, n);
+    } else {
+      pending = Math.max(pending, n);
+    }
+    pendingFromBr = false;
+  };
+  const write = (text, verbatim = false) => {
+    let s = text;
+    if (!s) {
+      return;
+    }
+    if (pending > 0 && out.length > 0) {
+      out += "\n".repeat(pending);
+      atLineStart = true;
+    }
+    pending = 0;
+    pendingFromBr = false;
+    if (atLineStart && !verbatim) {
+      s = s.replace(LEADING_SPACES, "");
+    }
+    if (!s) {
+      return;
+    }
+    out += s;
+    atLineStart = false;
+  };
+  for (const t of tokens) {
+    if (t.type === "comment" || t.type === "doctype") {
+      continue;
+    }
+    if (t.type === "open" || t.type === "close") {
+      const name = t.name;
+      if (SKIP_CONTENT.has(name)) {
+        if (t.type === "open" && !t.selfClosing) {
+          skipDepth += 1;
+        } else if (t.type === "close") {
+          skipDepth = Math.max(0, skipDepth - 1);
+        }
+        continue;
+      }
+      if (skipDepth) {
+        continue;
+      }
+      if (t.type === "open") {
+        if (name === "br") {
+          if (out.length === 0) {
+            continue;
+          }
+          if (pending > 0 && !pendingFromBr) {
+            pending = Math.max(pending, 2);
+          } else {
+            pending += 1;
+            pendingFromBr = true;
+          }
+          continue;
+        }
+        if (name === "hr") {
+          requestBreak(1);
+          if (out.length === 0) {
+            out = "_".repeat(32);
+          } else {
+            write("_".repeat(32));
+          }
+          atLineStart = false;
+          pending = 1;
+          pendingFromBr = false;
+          continue;
+        }
+        if (BLOCK_PARAGRAPH.has(name)) {
+          requestBreak(2);
+        } else if (BLOCK_LINE.has(name)) {
+          requestBreak(1);
+        }
+        if (name === "pre") {
+          preDepth += 1;
+        }
+        if (name === "li") {
+          requestBreak(1);
+          write("  *   ", true);
+          atLineStart = false;
+        }
+        if (name === "a") {
+          anchorStack.push(t.attrs?.find(([k]) => k.toLowerCase() === "href")?.[1] ?? null);
+        }
+        if (name === "td" || name === "th") {
+          write("	");
+        }
+        if (name === "img") {
+          const alt = t.attrs?.find(([k]) => k.toLowerCase() === "alt")?.[1];
+          if (alt) {
+            write(`[${alt}]`);
+          }
+        }
+      } else {
+        if (BLOCK_PARAGRAPH.has(name)) {
+          requestBreak(2);
+        } else if (BLOCK_LINE.has(name)) {
+          requestBreak(1);
+        }
+        if (name === "pre") {
+          preDepth = Math.max(0, preDepth - 1);
+        }
+        if (name === "a") {
+          const href = anchorStack.pop();
+          if (opts.links && href && !MAILTO_SCHEME.test(href) && !href.startsWith("#")) {
+            write(`<${href}>`);
+          }
+        }
+      }
+      continue;
+    }
+    if (skipDepth) {
+      continue;
+    }
+    let text = decodeEntities(t.raw);
+    if (!preDepth) {
+      text = text.replace(/[\r\n\t ]+/g, " ");
+      if (text === " " && (atLineStart || pending > 0)) {
+        continue;
+      }
+    }
+    write(text);
+  }
+  return out.replace(/ /g, " ").split("\n").map((l) => l.replace(TRAILING_SPACES, "")).join("\r\n").replace(LEADING_CRLFS, "").replace(TRAILING_CRLFS, "");
+}
+function bodyAsText(body) {
+  if (body.contentType === "text") {
+    const t2 = body.content.replace(/\r?\n/g, "\r\n");
+    return { contentType: "text", content: t2.endsWith("\r\n") ? t2 : `${t2}\r
+` };
+  }
+  const t = htmlToText(body.content, { links: true });
+  return { contentType: "text", content: `${t}\r
+` };
+}
+function bodyAsHtml(body) {
+  if (body.contentType === "html") {
+    return body;
+  }
+  const inner = body.content ? escapeHtml(body.content).replace(/\r?\n/g, "<br>\r\n") : "&nbsp;";
+  return {
+    contentType: "html",
+    content: `<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8">\r
+<meta name="Generator" content="Microsoft Exchange Server">\r
+<!-- converted from text -->\r
+<style><!-- .EmailQuote { margin-left: 1pt; padding-left: 4pt; border-left: #800000 2px solid; } --></style></head>\r
+<body>\r
+<font size="2"><span style="font-size:11pt;"><div class="PlainText">${inner}</div></span></font>\r
+</body>\r
+</html>\r
+`
+  };
+}
+function uniqueBodyAsHtml(body) {
+  if (body.contentType === "html") {
+    const inner2 = bodyInner(body.content).replace(/^[\r\n\t]+|[\r\n\t]+$/g, "");
+    const lead = BLOCK_ELEMENT_START.test(inner2) ? "\r\n" : "";
+    return { contentType: "html", content: `<html><body><div>\r
+<div>${lead}${inner2}</div></div>\r
+</body></html>` };
+  }
+  const inner = escapeHtml(body.content).replace(/\r?\n/g, "<br>\r\n");
+  return {
+    contentType: "html",
+    content: `<html><body><div>\r
+<div><font size="2"><span style="font-size:11pt;">${inner}</span></font></div>\r
+</div>\r
+</body></html>`
+  };
+}
+function expandTabs(text) {
+  return text.split("\r\n").map((line) => {
+    let out = "";
+    for (const ch of line) {
+      out += ch === "	" ? " ".repeat(8 - out.length % 8) : ch;
+    }
+    return out;
+  }).join("\r\n");
+}
+function bodyPreview(body) {
+  if (!body.content) {
+    return "";
+  }
+  const text = body.contentType === "html" ? expandTabs(htmlToText(body.content, { links: false })) : body.content.replace(/^\s+|\s+$/g, "");
+  return text.length > PREVIEW_LIMIT ? text.slice(0, PREVIEW_LIMIT).replace(TRAILING_WHITESPACE, "") : text;
+}
+function longDate(iso, locale = "en-GB") {
+  const d = new Date(iso);
+  const weekday = d.toLocaleDateString(locale, { weekday: "long", timeZone: "UTC" });
+  const day = d.getUTCDate();
+  const month = d.toLocaleDateString(locale, { month: "long", timeZone: "UTC" });
+  const time = d.toISOString().slice(11, 19);
+  return `${weekday}, ${day} ${month} ${d.getUTCFullYear()} ${time}`;
+}
+function fmtAddr(a) {
+  return `${escapeHtml(a.name || a.address)} &lt;${escapeHtml(a.address)}&gt;`;
+}
+function quoteBody(original, header2, comment) {
+  const lines = [];
+  if (header2.from) {
+    lines.push(`<b>From:</b> ${fmtAddr(header2.from)}`);
+  }
+  lines.push(`<b>Sent:</b> ${longDate(header2.sentDateTime)}`);
+  if (header2.to.length) {
+    lines.push(`<b>To:</b> ${header2.to.map(fmtAddr).join("; ")}`);
+  }
+  if (header2.cc.length) {
+    lines.push(`<b>Cc:</b> ${header2.cc.map(fmtAddr).join("; ")}`);
+  }
+  lines.push(`<b>Subject:</b> ${escapeHtml(header2.subject)}`);
+  const lead = comment ? normalizeInnerHtml(comment) : "";
+  if (original.contentType === "text") {
+    const text = original.content ? escapeHtml(original.content).replace(/\r?\n/g, "<br>") : "&nbsp;";
+    const inner2 = `<div>${lead}<hr tabindex="-1" style="display:inline-block; width:98%"><div id="x_divRplyFwdMsg" dir="ltr"><font face="Calibri, sans-serif" color="#000000" style="font-size:11pt">${lines.join("<br>")}</font><div>&nbsp;</div></div></div><font size="2"><span style="font-size:11pt"><div class="PlainText">${text}</div></span></font>`;
+    return { contentType: "html", content: `${TEXT_QUOTE_HEAD}<body>${inner2}</body></html>` };
+  }
+  const originalInner = bodyInner(original.content).replace(TRAILING_WHITESPACE, "");
+  const prefix = comment ? `${lead} ` : "";
+  const inner = `${prefix}<hr tabindex="-1" style="display:inline-block; width:98%"><div id="divRplyFwdMsg" dir="ltr"><font face="Calibri, sans-serif" color="#000000" style="font-size:11pt">${lines.join("<br>")}</font> <div>&nbsp;</div></div><div>${originalInner}</div>`;
+  return { contentType: "html", content: `${HTML_HEAD}<body>${inner}</body></html>` };
+}
+function commentBody(comment, original) {
+  const c = comment ? normalizeInnerHtml(comment) : "";
+  let fragment = c ? `${c} ` : "";
+  if (original.contentType === "text") {
+    fragment = `<div>${c}</div>`;
+  }
+  return { contentType: "html", content: `<html><body>${fragment}</body></html>` };
+}
+
+// src/graph/payload.ts
+var TIMEZONE_OFFSET = /[zZ]|[+-]\d{2}:\d{2}$/;
+var MILLISECONDS_FRACTION = /\.(\d{3})$/;
+var MESSAGE_WRITABLE = /* @__PURE__ */ new Set([
+  "subject",
+  "body",
+  "toRecipients",
+  "ccRecipients",
+  "bccRecipients",
+  "replyTo",
+  "from",
+  "sender",
+  "importance",
+  "isRead",
+  "isReadReceiptRequested",
+  "isDeliveryReceiptRequested",
+  "categories",
+  "flag",
+  "inferenceClassification",
+  "internetMessageId",
+  "internetMessageHeaders",
+  "attachments",
+  "singleValueExtendedProperties",
+  "multiValueExtendedProperties",
+  "extensions",
+  "mentions"
+]);
+var MESSAGE_READONLY = /* @__PURE__ */ new Set([
+  "id",
+  "createdDateTime",
+  "lastModifiedDateTime",
+  "changeKey",
+  "receivedDateTime",
+  "sentDateTime",
+  "hasAttachments",
+  "bodyPreview",
+  "parentFolderId",
+  "conversationId",
+  "conversationIndex",
+  "isDraft",
+  "webLink",
+  "uniqueBody"
+]);
+function unexpectedNode(prop, kind) {
+  return new GraphError(
+    400,
+    "RequestBodyRead",
+    `An unexpected '${kind}' node was found for property named '${prop}' when reading from the JSON reader. A 'PrimitiveValue' node was expected.`
+  );
+}
+function literal(v) {
+  if (typeof v === "string") {
+    return v;
+  }
+  return JSON.stringify(v);
+}
+function expectString(prop, v) {
+  if (v === null) {
+    return null;
+  }
+  if (typeof v === "string") {
+    return v;
+  }
+  if (Array.isArray(v)) {
+    throw unexpectedNode(prop, "StartArray");
+  }
+  if (typeof v === "object") {
+    throw unexpectedNode(prop, "StartObject");
+  }
+  throw Errors.literalConversion(literal(v), "Edm.String");
+}
+function expectBoolean(prop, v) {
+  if (typeof v === "boolean") {
+    return v;
+  }
+  if (Array.isArray(v)) {
+    throw unexpectedNode(prop, "StartArray");
+  }
+  if (v !== null && typeof v === "object") {
+    throw unexpectedNode(prop, "StartObject");
+  }
+  throw Errors.literalConversion(literal(v), "Edm.Boolean");
+}
+function expectEnum(v, members) {
+  if (typeof v !== "string") {
+    throw Errors.enumValueNotFound(literal(v));
+  }
+  const m = members.find((x2) => x2.toLowerCase() === v.toLowerCase());
+  if (!m) {
+    throw Errors.enumValueNotFound(v);
+  }
+  return m;
+}
+function expectObject(_prop, v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) {
+    throw new GraphError(
+      400,
+      "RequestBodyRead",
+      `An unexpected '${Array.isArray(v) ? "StartArray" : "PrimitiveValue"}' node was found when reading from the JSON reader. A 'StartObject' node was expected.`
+    );
+  }
+  return v;
+}
+function expectArray(_prop, v) {
+  if (v === null) {
+    return [];
+  }
+  if (!Array.isArray(v)) {
+    throw new GraphError(
+      400,
+      "RequestBodyRead",
+      `An unexpected '${typeof v === "object" ? "StartObject" : "PrimitiveValue"}' node was found when reading from the JSON reader. A 'StartArray' node was expected.`
+    );
+  }
+  return v;
+}
+function actionParams(body, names, action) {
+  const out = {};
+  for (const [k, v] of Object.entries(body)) {
+    if (k.includes("@odata.")) {
+      continue;
+    }
+    const name = names.find((n) => n.toLowerCase() === k.toLowerCase());
+    if (!name) {
+      throw Errors.unknownBodyProperty(k, action);
+    }
+    out[name] = v;
+  }
+  return out;
+}
+function checkKeys(obj, allowed, type) {
+  for (const k of Object.keys(obj)) {
+    if (k.startsWith("@odata.") || k.includes("@odata.")) {
+      continue;
+    }
+    if (!allowed.includes(k)) {
+      throw Errors.unknownBodyProperty(k, type);
+    }
+  }
+}
+function parseRecipient(ex, v, prop) {
+  const o = expectObject(prop, v);
+  checkKeys(o, ["emailAddress"], "recipient");
+  const ea = o.emailAddress === void 0 || o.emailAddress === null ? {} : expectObject("emailAddress", o.emailAddress);
+  checkKeys(ea, ["address", "name"], "emailAddress");
+  const address = expectString("address", ea.address ?? null);
+  const name = expectString("name", ea.name ?? null);
+  return ex.resolveRecipient({ emailAddress: { address: address ?? "", name } });
+}
+function parseRecipients(ex, v, prop) {
+  return expectArray(prop, v).map((r) => parseRecipient(ex, r, prop));
+}
+function parseBody(v) {
+  if (v === null) {
+    return { contentType: "text", content: "" };
+  }
+  const o = expectObject("body", v);
+  checkKeys(o, ["contentType", "content"], "itemBody");
+  const contentType = o.contentType === void 0 || o.contentType === null ? "text" : expectEnum(o.contentType, ["text", "html"]);
+  const content = expectString("content", o.content ?? "") ?? "";
+  return storeBody({ contentType, content });
+}
+function parseDateTimeTimeZone(v, prop) {
+  if (v === null || v === void 0) {
+    return void 0;
+  }
+  const o = expectObject(prop, v);
+  checkKeys(o, ["dateTime", "timeZone"], "dateTimeTimeZone");
+  const dt = expectString("dateTime", o.dateTime ?? null);
+  if (!dt) {
+    throw Errors.requiredProperty("dateTime");
+  }
+  const d = new Date(TIMEZONE_OFFSET.test(dt) ? dt : `${dt}Z`);
+  const iso = Number.isNaN(d.getTime()) ? dt : d.toISOString().replace("Z", "").replace(MILLISECONDS_FRACTION, ".$10000");
+  return { dateTime: iso, timeZone: o.timeZone ?? "UTC" };
+}
+function parseFlag(v) {
+  const o = expectObject("flag", v);
+  checkKeys(o, ["flagStatus", "startDateTime", "dueDateTime", "completedDateTime"], "followupFlag");
+  const status = o.flagStatus === void 0 ? "notFlagged" : expectEnum(o.flagStatus, ["notFlagged", "complete", "flagged"]);
+  const flag = { flagStatus: status };
+  const start = parseDateTimeTimeZone(o.startDateTime, "startDateTime");
+  const due = parseDateTimeTimeZone(o.dueDateTime, "dueDateTime");
+  const completed = parseDateTimeTimeZone(o.completedDateTime, "completedDateTime");
+  if (status === "flagged") {
+    if (start) {
+      flag.startDateTime = start;
+    }
+    if (due) {
+      flag.dueDateTime = due;
+    }
+  }
+  if (status === "complete" && completed) {
+    flag.completedDateTime = {
+      dateTime: `${completed.dateTime.slice(0, 10)}T00:00:00.0000000`,
+      timeZone: completed.timeZone
+    };
+  }
+  return flag;
+}
+function parseMessageInput(ex, input, mode) {
+  const fields = {};
+  const present = /* @__PURE__ */ new Set();
+  let attachments = null;
+  for (const [k, v] of Object.entries(input)) {
+    if (k.startsWith("@odata.") || k.includes("@odata.")) {
+      continue;
+    }
+    if (MESSAGE_READONLY.has(k)) {
+      continue;
+    }
+    if (!MESSAGE_WRITABLE.has(k)) {
+      throw Errors.unknownBodyProperty(k, "message");
+    }
+    switch (k) {
+      case "subject":
+        fields.subject = expectString(k, v) ?? "";
+        break;
+      case "body":
+        fields.body = parseBody(v);
+        break;
+      case "toRecipients":
+      case "ccRecipients":
+      case "bccRecipients":
+      case "replyTo":
+        fields[k] = parseRecipients(ex, v, k);
+        break;
+      case "from":
+      case "sender":
+        fields[k] = v === null ? null : parseRecipient(ex, v, k);
+        break;
+      case "importance":
+        fields.importance = expectEnum(v, ["low", "normal", "high"]);
+        break;
+      case "inferenceClassification":
+        fields.inferenceClassification = expectEnum(v, ["focused", "other"]);
+        break;
+      case "isRead":
+      case "isReadReceiptRequested":
+      case "isDeliveryReceiptRequested":
+        fields[k] = expectBoolean(k, v);
+        break;
+      case "categories":
+        fields.categories = expectArray(k, v).map((c) => expectString(k, c) ?? "");
+        break;
+      case "flag":
+        fields.flag = parseFlag(v);
+        break;
+      case "internetMessageId":
+        if (mode !== "create") {
+          continue;
+        }
+        fields.internetMessageId = expectString(k, v) ?? "";
+        break;
+      case "internetMessageHeaders": {
+        if (mode === "update") {
+          continue;
+        }
+        const list = expectArray(k, v).map((h) => {
+          const o = expectObject(k, h);
+          checkKeys(o, ["name", "value"], "internetMessageHeader");
+          return { name: String(o.name ?? ""), value: String(o.value ?? "") };
+        });
+        fields.internetMessageHeaders = list;
+        break;
+      }
+      case "attachments":
+        attachments = expectArray(k, v);
+        break;
+      case "singleValueExtendedProperties":
+        fields.singleValueExtendedProperties = expectArray(k, v).map((p) => {
+          const o = expectObject(k, p);
+          return { id: String(o.id ?? ""), value: String(o.value ?? "") };
+        });
+        break;
+      case "multiValueExtendedProperties":
+        fields.multiValueExtendedProperties = expectArray(k, v).map((p) => {
+          const o = expectObject(k, p);
+          return { id: String(o.id ?? ""), value: expectArray("value", o.value).map(String) };
+        });
+        break;
+      case "extensions":
+        fields.extensions = expectArray(k, v).map((e) => expectObject(k, e));
+        break;
+      case "mentions":
+        break;
+      default:
+        break;
+    }
+    present.add(k);
+  }
+  return { fields, present, attachments };
+}
+
+// src/graph/serialize.ts
+import { createHash } from "crypto";
+var COLLECTION_TYPE = /^Collection\((.*)\)$/;
+var GRAPH_TYPE_CAST_PREFIX = /^microsoft\.graph\.\w+\//;
+var MESSAGE_PROPERTIES = [
+  { name: "createdDateTime", type: "Edm.DateTimeOffset", default: true },
+  { name: "lastModifiedDateTime", type: "Edm.DateTimeOffset", default: true },
+  { name: "changeKey", type: "Edm.String", default: true },
+  { name: "categories", type: "Collection(Edm.String)", default: true, freeFilter: true },
+  { name: "receivedDateTime", type: "Edm.DateTimeOffset", default: true },
+  { name: "sentDateTime", type: "Edm.DateTimeOffset", default: true },
+  { name: "hasAttachments", type: "Edm.Boolean", default: true },
+  { name: "internetMessageId", type: "Edm.String", default: true },
+  { name: "subject", type: "Edm.String", default: true },
+  { name: "bodyPreview", type: "Edm.String", default: true },
+  { name: "importance", type: "importance", default: true },
+  { name: "parentFolderId", type: "Edm.String", default: true },
+  { name: "conversationId", type: "Edm.String", default: true },
+  { name: "conversationIndex", type: "Edm.Binary", default: true },
+  { name: "isDeliveryReceiptRequested", type: "Edm.Boolean", default: true },
+  { name: "isReadReceiptRequested", type: "Edm.Boolean", default: true },
+  { name: "isRead", type: "Edm.Boolean", default: true, freeFilter: true, unsortable: true },
+  { name: "isDraft", type: "Edm.Boolean", default: true, freeFilter: true },
+  { name: "webLink", type: "Edm.String", default: true },
+  { name: "inferenceClassification", type: "inferenceClassificationType", default: true },
+  { name: "body", type: "itemBody", default: true },
+  { name: "sender", type: "recipient", default: true },
+  { name: "from", type: "recipient", default: true },
+  { name: "toRecipients", type: "Collection(recipient)", default: true },
+  { name: "ccRecipients", type: "Collection(recipient)", default: true },
+  { name: "bccRecipients", type: "Collection(recipient)", default: true },
+  { name: "replyTo", type: "Collection(recipient)", default: true },
+  { name: "flag", type: "followupFlag", default: true },
+  { name: "uniqueBody", type: "itemBody", default: false },
+  { name: "internetMessageHeaders", type: "Collection(internetMessageHeader)", default: false }
+];
+var MESSAGE_NAVIGATION = [
+  "attachments",
+  "extensions",
+  "singleValueExtendedProperties",
+  "multiValueExtendedProperties"
+];
+var COMPLEX_TYPES = {
+  itemBody: { contentType: "bodyType", content: "Edm.String" },
+  recipient: { emailAddress: "emailAddress" },
+  emailAddress: { name: "Edm.String", address: "Edm.String" },
+  followupFlag: {
+    flagStatus: "followupFlagStatus",
+    startDateTime: "dateTimeTimeZone",
+    dueDateTime: "dateTimeTimeZone",
+    completedDateTime: "dateTimeTimeZone"
+  },
+  dateTimeTimeZone: { dateTime: "Edm.String", timeZone: "Edm.String" },
+  internetMessageHeader: { name: "Edm.String", value: "Edm.String" }
+};
+function messagePathType(path) {
+  if (path[0] === "id") {
+    return "Edm.String";
+  }
+  const p = MESSAGE_PROPERTIES.find((x2) => x2.name.toLowerCase() === path[0].toLowerCase());
+  if (!p) {
+    return null;
+  }
+  let t = p.type;
+  for (const seg of path.slice(1)) {
+    const inner = COLLECTION_TYPE.exec(t)?.[1] ?? t;
+    const c = COMPLEX_TYPES[inner];
+    if (!c) {
+      return null;
+    }
+    const key = Object.keys(c).find((k) => k.toLowerCase() === seg.toLowerCase());
+    if (!key) {
+      return null;
+    }
+    t = c[key];
+  }
+  return t;
+}
+var IMPORTANCE_RANK = { low: 0, normal: 1, high: 2 };
+function importanceRank(v) {
+  return typeof v === "string" && v in IMPORTANCE_RANK ? IMPORTANCE_RANK[v] : v;
+}
+function messageValue(ex, mbx, m, path) {
+  const head = path[0].toLowerCase();
+  let v;
+  switch (head) {
+    case "id":
+      return ex.itemId(mbx, m);
+    case "hasattachments":
+      return m.attachments.some((a) => !a.isInline);
+    case "isdraft":
+      return m.state === "draft";
+    case "bodypreview":
+      return bodyPreview(m.body);
+    case "parentfolderid":
+      return ex.folderId(mbx, m.folderCounter);
+    case "conversationid":
+      return ex.conversationId(mbx, m);
+    case "changekey":
+      return ex.changeKey(mbx, m);
+    default: {
+      const key = Object.keys(m).find((k) => k.toLowerCase() === head);
+      v = key ? m[key] : void 0;
+    }
+  }
+  for (const seg of path.slice(1)) {
+    if (v === null || v === void 0) {
+      return null;
+    }
+    if (typeof v === "object") {
+      const obj = v;
+      const key = Object.keys(obj).find((k) => k.toLowerCase() === seg.toLowerCase());
+      v = key ? obj[key] : void 0;
+    }
+  }
+  return v ?? null;
+}
+function flagJson(m) {
+  const f = { flagStatus: m.flag.flagStatus };
+  if (m.flag.flagStatus === "flagged") {
+    if (m.flag.dueDateTime) {
+      f.dueDateTime = m.flag.dueDateTime;
+    }
+    if (m.flag.startDateTime) {
+      f.startDateTime = m.flag.startDateTime;
+    }
+  }
+  if (m.flag.flagStatus === "complete" && m.flag.completedDateTime) {
+    f.completedDateTime = m.flag.completedDateTime;
+  }
+  return f;
+}
+function webLink(ex, mbx, m, immutable = false) {
+  const std = Buffer.from(ex.itemId(mbx, m, immutable).replace(/-/g, "/").replace(/_/g, "+"), "base64").toString(
+    "base64"
+  );
+  return `https://outlook.office365.com/owa/?ItemID=${encodeURIComponent(std)}&exvsurl=1&viewmodel=ReadMessageItem`;
+}
+function propertyValue(ex, mbx, m, name, opts) {
+  switch (name) {
+    case "createdDateTime":
+      return m.createdDateTime;
+    case "lastModifiedDateTime":
+      return m.lastModifiedDateTime;
+    case "changeKey":
+      return ex.changeKey(mbx, m);
+    case "categories":
+      return [...m.categories];
+    case "receivedDateTime":
+      return m.receivedDateTime;
+    case "sentDateTime":
+      return m.sentDateTime;
+    case "hasAttachments":
+      return m.attachments.some((a) => !a.isInline);
+    case "internetMessageId":
+      return m.internetMessageId;
+    case "subject":
+      return m.subject;
+    case "bodyPreview":
+      return bodyPreview(m.body);
+    case "importance":
+      return m.importance;
+    case "parentFolderId":
+      return ex.folderId(mbx, m.folderCounter);
+    case "conversationId":
+      return ex.conversationId(mbx, m);
+    case "conversationIndex":
+      return m.conversationIndex;
+    case "isDeliveryReceiptRequested":
+      return m.isDeliveryReceiptRequested;
+    case "isReadReceiptRequested":
+      return m.isReadReceiptRequested;
+    case "isRead":
+      return m.isRead;
+    case "isDraft":
+      return m.state === "draft" || m.state === "submitted";
+    case "webLink":
+      return webLink(ex, mbx, m, opts.immutableIds);
+    case "inferenceClassification":
+      return m.inferenceClassification;
+    case "body":
+      if (opts.bodyType === "text" && m.body.contentType === "html") {
+        return m.textBody === void 0 ? bodyAsText(m.body) : { contentType: "text", content: m.textBody };
+      }
+      if (opts.bodyType === "html") {
+        return bodyAsHtml(m.body);
+      }
+      return { ...m.body };
+    case "uniqueBody": {
+      const u = m.uniqueBody ?? m.body;
+      if (opts.bodyType === "html") {
+        return uniqueBodyAsHtml(u);
+      }
+      const draft = m.state === "draft" || m.state === "submitted";
+      if (opts.bodyType !== "text" && !draft && u.contentType === "html") {
+        return uniqueBodyAsHtml(u);
+      }
+      return bodyAsText(u);
+    }
+    case "sender":
+      return m.sender;
+    case "from":
+      return m.from;
+    case "toRecipients":
+      return m.toRecipients;
+    case "ccRecipients":
+      return m.ccRecipients;
+    case "bccRecipients":
+      return m.bccRecipients;
+    case "replyTo":
+      return m.replyTo;
+    case "flag":
+      return flagJson(m);
+    case "internetMessageHeaders":
+      return m.internetMessageHeaders;
+    default:
+      break;
+  }
+  return void 0;
+}
+function canonicalMessageSelect(select) {
+  const names = [];
+  const nav = [];
+  for (const s of select) {
+    if (s === "*") {
+      names.push(...MESSAGE_PROPERTIES.filter((property) => property.default).map((property) => property.name));
+      continue;
+    }
+    const raw = s.replace(GRAPH_TYPE_CAST_PREFIX, "");
+    if (raw.toLowerCase() === "id") {
+      names.push("id");
+      continue;
+    }
+    const p = MESSAGE_PROPERTIES.find((x2) => x2.name.toLowerCase() === raw.toLowerCase());
+    if (p) {
+      names.push(p.name);
+      continue;
+    }
+    const n = MESSAGE_NAVIGATION.find((x2) => x2.toLowerCase() === raw.toLowerCase());
+    if (n) {
+      nav.push(n);
+      continue;
+    }
+    throw Errors.parseUriProperty(raw, "Microsoft.OutlookServices.Message", true);
+  }
+  return { names: [...new Set(names)], nav: [...new Set(nav)] };
+}
+function renderMessage(ex, mbx, m, opts) {
+  const out = {};
+  out["@odata.etag"] = `W/"${ex.changeKey(mbx, m)}"`;
+  out.id = ex.itemId(mbx, m, opts.immutableIds);
+  const selected = opts.select ? new Set(opts.select) : null;
+  const isDraftLike = m.state === "draft";
+  for (const p of MESSAGE_PROPERTIES) {
+    if (selected ? !selected.has(p.name) : !p.default) {
+      continue;
+    }
+    if ((p.name === "sender" || p.name === "from") && !selected && isDraftLike && !m[p.name]) {
+      continue;
+    }
+    if ((p.name === "sender" || p.name === "from") && selected && !m[p.name]) {
+      continue;
+    }
+    if (p.name === "internetMessageHeaders" && !m.internetMessageHeaders) {
+      continue;
+    }
+    if (p.name === "webLink" && selected === null) {
+      out.webLink = webLink(ex, mbx, m, opts.immutableIds);
+      continue;
+    }
+    let v = propertyValue(ex, mbx, m, p.name, opts);
+    if (p.name === "parentFolderId") {
+      v = ex.folderId(mbx, m.folderCounter);
+    }
+    out[p.name] = v;
+  }
+  if (opts.expandAttachments) {
+    out.attachments = m.attachments.map((a) => renderAttachment(ex, mbx, m, a, true));
+  }
+  if (m.sharing) {
+    return withSharingProperties(out, m.sharing, selected === null);
+  }
+  return m.meeting ? withMeetingProperties(out, m.meeting, selected === null) : out;
+}
+function withSharingProperties(base, info, full) {
+  const out = { "@odata.type": "#microsoft.graph.calendarSharingMessage" };
+  if (!full) {
+    return Object.assign(out, base);
+  }
+  const action = { importance: "primary", actionType: "accept", action: "acceptAndViewCalendar" };
+  for (const [k, v] of Object.entries(base)) {
+    out[k] = v;
+    if (k === "inferenceClassification") {
+      out.canAccept = true;
+      out.suggestedCalendarName = info.suggestedCalendarName;
+    }
+  }
+  out.sharingMessageAction = action;
+  out.sharingMessageActions = [action];
+  return out;
+}
+var MEETING_TYPE = {
+  request: "#microsoft.graph.eventMessageRequest",
+  response: "#microsoft.graph.eventMessageResponse",
+  cancellation: "#microsoft.graph.eventMessage"
+};
+function utcDtz(ms) {
+  const iso = new Date(ms).toISOString();
+  return { dateTime: `${iso.slice(0, 19)}.${iso.slice(20, 23)}0000`, timeZone: "UTC" };
+}
+function withMeetingProperties(base, info, full) {
+  const out = { "@odata.type": MEETING_TYPE[info.kind] };
+  if (!full) {
+    return Object.assign(out, base);
+  }
+  const scalars = {
+    meetingMessageType: info.meetingMessageType,
+    type: info.type,
+    isOutOfDate: false,
+    isAllDay: info.isAllDay,
+    isDelegated: false
+  };
+  if (info.kind === "request") {
+    scalars.responseRequested = info.responseRequested;
+    scalars.allowNewTimeProposals = null;
+    scalars.meetingRequestType = info.meetingRequestType ?? "newMeetingRequest";
+  }
+  if (info.kind === "response") {
+    scalars.responseType = info.responseType ?? "none";
+  }
+  scalars.recurrence = info.recurrence;
+  const tail = {
+    startDateTime: utcDtz(info.startMs),
+    endDateTime: utcDtz(info.endMs)
+  };
+  const located = Boolean(info.location.displayName);
+  if (located) {
+    tail.location = { ...info.location };
+  }
+  if (info.kind === "request") {
+    tail.previousLocation = info.previous ? { ...info.previous.location } : null;
+    tail.previousStartDateTime = utcDtz(info.previous ? info.previous.startMs : info.startMs);
+    tail.previousEndDateTime = utcDtz(info.previous ? info.previous.endMs : info.endMs);
+  }
+  if (info.kind === "response" && info.proposedNewTime) {
+    tail.proposedNewTime = info.proposedNewTime ? { start: utcDtz(info.proposedNewTime.startMs), end: utcDtz(info.proposedNewTime.endMs) } : null;
+  }
+  for (const [k, v] of Object.entries(base)) {
+    if (k === "body") {
+      Object.assign(out, scalars);
+    }
+    out[k] = v;
+    if (k === "flag") {
+      Object.assign(out, tail);
+    }
+  }
+  if (!("body" in base)) {
+    Object.assign(out, scalars);
+  }
+  if (!("flag" in base)) {
+    Object.assign(out, tail);
+  }
+  return out;
+}
+var FOLDER_PROPERTIES = [
+  "displayName",
+  "parentFolderId",
+  "childFolderCount",
+  "unreadItemCount",
+  "totalItemCount",
+  "sizeInBytes",
+  "wellKnownName",
+  "isHidden"
+];
+var FOLDER_SELECTABLE = [
+  "id",
+  "displayName",
+  "parentFolderId",
+  "childFolderCount",
+  "unreadItemCount",
+  "totalItemCount",
+  "isHidden"
+];
+function renderFolder(ex, mbx, f, select) {
+  const counts = ex.counts(mbx, f);
+  const all = {
+    displayName: f.displayName,
+    parentFolderId: f.parentCounter === null ? null : ex.folderId(mbx, f.parentCounter),
+    childFolderCount: counts.childFolderCount,
+    unreadItemCount: counts.unreadItemCount,
+    totalItemCount: counts.totalItemCount,
+    sizeInBytes: counts.sizeInBytes,
+    wellKnownName: f.wellKnownName,
+    isHidden: f.isHidden
+  };
+  const out = f.search ? { "@odata.type": "#microsoft.graph.mailSearchFolder", id: ex.folderId(mbx, f) } : { id: ex.folderId(mbx, f) };
+  for (const k of FOLDER_PROPERTIES) {
+    if (select && !select.includes(k)) {
+      continue;
+    }
+    out[k] = all[k];
+  }
+  if (f.search) {
+    const search = f.search.unsupported ? { isSupported: false } : {
+      isSupported: true,
+      includeNestedFolders: f.search.includeNestedFolders,
+      sourceFolderIds: f.search.sourceFolderCounters.map((c) => ex.folderId(mbx, c)),
+      filterQuery: f.search.filterQuery
+    };
+    for (const [k, v] of Object.entries(search)) {
+      if (select && !select.some((x2) => x2.toLowerCase() === k.toLowerCase())) {
+        continue;
+      }
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function canonicalFolderSelect(select) {
+  const out = [];
+  for (const s of select) {
+    const k = FOLDER_SELECTABLE.find((x2) => x2.toLowerCase() === s.toLowerCase());
+    if (!k) {
+      const nav = [
+        "childFolders",
+        "messages",
+        "messageRules",
+        "singleValueExtendedProperties",
+        "multiValueExtendedProperties"
+      ].find((x2) => x2.toLowerCase() === s.toLowerCase());
+      if (nav) {
+        continue;
+      }
+      throw Errors.selectExpandParse(s, "mailFolder");
+    }
+    out.push(k);
+  }
+  return [...new Set(out)];
+}
+function folderValue(ex, mbx, f, path) {
+  const r = renderFolder(ex, mbx, f, null);
+  const key = Object.keys(r).find((k) => k.toLowerCase() === path[0].toLowerCase());
+  return key ? r[key] : void 0;
+}
+function folderPathType(path) {
+  const types = {
+    id: "Edm.String",
+    displayName: "Edm.String",
+    parentFolderId: "Edm.String",
+    childFolderCount: "Edm.Int32",
+    unreadItemCount: "Edm.Int32",
+    totalItemCount: "Edm.Int32",
+    isHidden: "Edm.Boolean"
+  };
+  if (path.length !== 1) {
+    return null;
+  }
+  const k = Object.keys(types).find((x2) => x2.toLowerCase() === path[0].toLowerCase());
+  return k ? types[k] : null;
+}
+function attachmentId(ex, mbx, m, a) {
+  const item = Buffer.from(ex.itemId(mbx, m).replace(/-/g, "/").replace(/_/g, "+"), "base64");
+  const key = createHash("sha1").update(`${mbx.guid}:${a.counter}`).digest().subarray(0, 16);
+  key.writeUInt32BE(a.counter >>> 0, 12);
+  return Buffer.concat([item, Buffer.from([1, 18, 0, 16, 0]), key]).toString("base64").replace(/\//g, "-").replace(/\+/g, "_");
+}
+function decodeAttachmentId(id) {
+  const buf = Buffer.from(id.replace(/-/g, "/").replace(/_/g, "+"), "base64");
+  const n = buf.length - 21;
+  if (n !== 111 && n !== 113) {
+    return null;
+  }
+  if (buf[n] !== 1 || buf[n + 1] !== 18 || buf[n + 3] !== 16) {
+    return null;
+  }
+  const itemId = buf.subarray(0, n).toString("base64").replace(/\//g, "-").replace(/\+/g, "_");
+  return { itemId, counter: buf.readUInt32BE(n + 17) };
+}
+function renderAttachment(ex, mbx, m, a, withContent, select = null) {
+  const id = attachmentId(ex, mbx, m, a);
+  let out;
+  if (a.type === "file") {
+    out = {
+      "@odata.type": "#microsoft.graph.fileAttachment",
+      "@odata.mediaContentType": a.contentType,
+      id,
+      lastModifiedDateTime: a.lastModifiedDateTime,
+      name: a.name,
+      contentType: a.contentType,
+      size: a.size,
+      isInline: a.isInline,
+      contentId: a.contentId,
+      contentLocation: a.contentLocation
+    };
+    if (withContent) {
+      out.contentBytes = a.contentBytes;
+    }
+  } else if (a.type === "item") {
+    out = {
+      "@odata.type": "#microsoft.graph.itemAttachment",
+      id,
+      lastModifiedDateTime: a.lastModifiedDateTime,
+      name: a.name,
+      contentType: null,
+      size: a.size,
+      isInline: a.isInline
+    };
+  } else {
+    out = {
+      "@odata.type": "#microsoft.graph.referenceAttachment",
+      id,
+      lastModifiedDateTime: a.lastModifiedDateTime,
+      name: a.name,
+      contentType: a.contentType,
+      size: a.size,
+      isInline: a.isInline
+    };
+  }
+  if (select) {
+    const keep = /* @__PURE__ */ new Set(["@odata.type", "@odata.mediaContentType", "id", ...select]);
+    for (const k of Object.keys(out)) {
+      if (!keep.has(k)) {
+        delete out[k];
+      }
+    }
+  }
+  return out;
+}
+
+// src/graph/handlers/upload.ts
+var MILLISECONDS_SUFFIX_GROUP = /\.(\d{3})Z$/;
+var CONTENT_RANGE = /^bytes (\d+)-(\d+)\/(\d+|\*)$/;
+var MAX_SIZE = 150 * 1024 * 1024;
+var SESSION_TTL_MS = 2 * 60 * 60 * 1e3;
+function ticksIso(d) {
+  return d.toISOString().replace(
+    MILLISECONDS_SUFFIX_GROUP,
+    (_m, ms) => `.${ms}${String(Math.floor(Math.random() * 1e4)).padStart(4, "0")}Z`
+  );
+}
+function sessionId() {
+  return Buffer.concat([Buffer.from([0, 0]), randomBytes4(68)]).toString("base64").replace(/\//g, "-").replace(/\+/g, "_");
+}
+function createUploadSession(c, m, collection = "messages", itemKey) {
+  const body = parseJsonBody(c.req);
+  const key = Object.keys(body).find((k) => k.toLowerCase() === "attachmentitem");
+  if (!key || body[key] === null || body[key] === void 0) {
+    throw Errors.missingParameters("createUploadSession", ["AttachmentItem"]);
+  }
+  const item = body[key];
+  if (typeof item !== "object" || Array.isArray(item)) {
+    throw Errors.unreadableJson();
+  }
+  for (const k of Object.keys(item)) {
+    if (!(["attachmentType", "name", "size", "isInline", "contentType", "contentId"].includes(k) || k.startsWith("@odata"))) {
+      throw Errors.unknownBodyProperty(k, "attachmentItem");
+    }
+  }
+  const type = item.attachmentType === void 0 ? "file" : expectEnum(item.attachmentType, ["file", "item", "reference"]);
+  if (type !== "file") {
+    throw Errors.notImplemented(`upload sessions for ${type} attachments`);
+  }
+  const size = typeof item.size === "number" ? item.size : 0;
+  if (size <= 0) {
+    throw Errors.attachmentTooSmall();
+  }
+  if (size > MAX_SIZE) {
+    throw Errors.attachmentTooLarge();
+  }
+  const name = expectString("name", item.name ?? null) ?? "";
+  const id = sessionId();
+  const authtoken = randomBytes4(64).toString("base64url");
+  const expires = new Date(Date.now() + SESSION_TTL_MS);
+  const rec = {
+    id,
+    mailboxGuid: c.mbx.guid,
+    itemCounter: m.immutableCounter,
+    name,
+    contentType: item.contentType === void 0 || item.contentType === null ? "application/octet-stream" : expectString("contentType", item.contentType) ?? "application/octet-stream",
+    isInline: item.isInline === void 0 ? false : expectBoolean("isInline", item.isInline),
+    contentId: item.contentId ? expectString("contentId", item.contentId) : null,
+    size,
+    received: 0,
+    chunks: [],
+    expirationDateTime: ticksIso(expires),
+    authtoken,
+    completed: false,
+    collection
+  };
+  c.ex.state.uploadSessions[id] = rec;
+  const tenant = c.ex.state.tenantId;
+  const msgId = itemKey ?? c.ex.itemId(c.mbx, m);
+  return {
+    status: 201,
+    headers: { "Content-Type": ODATA_JSON },
+    body: {
+      "@odata.context": `${c.base}/$metadata#microsoft.graph.uploadSession`,
+      uploadUrl: `${c.svc.baseUrl}/api/gv1.0/users('${c.mbx.guid}@${tenant}')/${collection}('${msgId}')/AttachmentSessions('${id}')?authtoken=${authtoken}`,
+      expirationDateTime: rec.expirationDateTime,
+      nextExpectedRanges: ["0-"]
+    }
+  };
+}
+function outlookError(err, requestId) {
+  const r = renderError(new GraphError(err.status, err.code, err.message, "exchange"), {
+    requestId,
+    clientRequestId: requestId
+  });
+  return {
+    status: r.status,
+    headers: { "Content-Type": OUTLOOK_JSON, "OData-Version": "4.0", "request-id": requestId },
+    body: r.body
+  };
+}
+function cancelUploadSession(ex, params) {
+  const requestId = randomUUID3();
+  const rec = ex.state.uploadSessions[params.session];
+  if (!rec || rec.completed || params.authtoken !== rec.authtoken || Date.parse(rec.expirationDateTime) < Date.now()) {
+    return outlookError(Errors.attachmentNotFound(), requestId);
+  }
+  delete ex.state.uploadSessions[params.session];
+  return { status: 204, headers: { "request-id": requestId }, body: null };
+}
+function uploadChunk(ex, baseUrl, params) {
+  const requestId = randomUUID3();
+  const rec = ex.state.uploadSessions[params.session];
+  const mbx = rec ? ex.mailboxByGuid(rec.mailboxGuid) : void 0;
+  if (!rec || rec.completed || !mbx || params.authtoken !== rec.authtoken || Date.parse(rec.expirationDateTime) < Date.now()) {
+    return outlookError(Errors.attachmentNotFound(), requestId);
+  }
+  const range = CONTENT_RANGE.exec((params.contentRange ?? "").trim());
+  if (!range) {
+    return outlookError(Errors.uploadInvalidRange(), requestId);
+  }
+  const start = Number(range[1]);
+  const end = Number(range[2]);
+  if (start !== rec.received) {
+    return outlookError(Errors.uploadInvalidStart(), requestId);
+  }
+  if (end < start || end - start + 1 !== params.bytes.length || end >= rec.size) {
+    return outlookError(Errors.uploadInvalidRange(), requestId);
+  }
+  rec.chunks.push(params.bytes.toString("base64"));
+  rec.received = end + 1;
+  const counter = mbx.immutable[rec.itemCounter];
+  const isEvent = rec.collection === "events";
+  let item;
+  if (counter !== void 0 && counter >= 0) {
+    item = isEvent ? mbx.events?.[counter] : mbx.items[counter];
+  }
+  if (!item) {
+    return outlookError(Errors.attachmentNotFound(), requestId);
+  }
+  const collection = isEvent ? "events" : "messages";
+  const msgId = isEvent ? eventId(mbx, item) : ex.itemId(mbx, item);
+  const userKey = `${mbx.guid}@${ex.state.tenantId}`;
+  if (rec.received < rec.size) {
+    return {
+      status: 200,
+      headers: { "Content-Type": OUTLOOK_JSON, "OData-Version": "4.0", "request-id": requestId },
+      body: {
+        "@odata.context": `${baseUrl}/api/gv1.0/$metadata#users('${encodeURIComponent(userKey)}')/${collection}('${msgId}')/attachmentSessions/$entity`,
+        expirationDateTime: rec.expirationDateTime,
+        nextExpectedRanges: [String(rec.received)]
+      }
+    };
+  }
+  const data = Buffer.concat(rec.chunks.map((s) => Buffer.from(s, "base64")));
+  const a = {
+    counter: ex.alloc(mbx),
+    type: "file",
+    name: rec.name,
+    contentType: rec.contentType,
+    isInline: rec.isInline,
+    contentId: rec.contentId,
+    contentLocation: null,
+    contentBytes: data.toString("base64"),
+    item: null,
+    // One observation (upload-session): 41 + 6 per name character + 2 per content type character.
+    size: data.length + 41 + 6 * rec.name.length + 2 * rec.contentType.length,
+    lastModifiedDateTime: isoSeconds()
+  };
+  item.attachments.push(a);
+  if (isEvent) {
+    touchEvent(ex, mbx, item);
+  } else {
+    ex.touch(mbx, item);
+  }
+  rec.completed = true;
+  rec.chunks = [];
+  delete ex.state.uploadSessions[rec.id];
+  return {
+    status: 201,
+    headers: {
+      Location: `${baseUrl}/api/gv1.0/users('${userKey}')/${collection}('${msgId}')/Attachments('${attachmentId(ex, mbx, item, a)}')`,
+      "request-id": requestId
+    },
+    body: null
+  };
+}
+
+export {
+  GraphError,
+  TodoErrors,
+  Errors,
+  wwwAuthenticate,
+  exchangeBase64,
+  fromExchangeBase64,
+  encodeFolderId,
+  encodeItemId,
+  immutableEntryIdBytes,
+  restImmutableFromEntryId,
+  foreignEntryIdToRest,
+  encodeImmutableId,
+  decodeId,
+  encodeChangeKey,
+  newConversationIndex,
+  childConversationIndex,
+  newInternetMessageId,
+  urlSafeBinary,
+  fromUrlSafeBinary,
+  entryIdBytes,
+  parseEntryId,
+  isoSeconds,
+  Exchange,
+  getExchange,
+  ATTENDEE_EMPTY_BODY,
+  HTML_HEAD,
+  escapeHtml,
+  bodyInner,
+  storeBody,
+  htmlToText,
+  bodyAsText,
+  bodyAsHtml,
+  bodyPreview,
+  quoteBody,
+  commentBody,
+  resolveZone,
+  offsetAt,
+  parseLocal,
+  wallToUtc,
+  utcToWall,
+  formatGraphDateTime,
+  displayZoneName,
+  DAY,
+  ZERO_TIME,
+  occurrenceGoid,
+  isCalendarFolder,
+  defaultCalendar,
+  calendarGroups,
+  groupOfCalendar,
+  calendarFolders,
+  calendarId,
+  calendarByNavId,
+  calendarMeta,
+  CALENDAR_COLORS,
+  eventsOf,
+  eventChangeKey,
+  eventLongChangeKey,
+  eventId,
+  occurrenceId,
+  occurrenceKey,
+  eventsIn,
+  emptyLocation,
+  newEvent,
+  createdStamp,
+  touchEvent,
+  purgeEvent,
+  deleteEvent,
+  exceptionsOf,
+  dateOnly,
+  formatDate,
+  localDate,
+  expandSeries,
+  occurrenceOn,
+  firstSeriesDate,
+  occurrenceView,
+  json,
+  noContent,
+  errorResponse,
+  newRequestId,
+  parseJsonBody,
+  parsePrefer,
+  contextUserKey,
+  expectString,
+  expectBoolean,
+  expectEnum,
+  expectObject,
+  expectArray,
+  actionParams,
+  checkKeys,
+  parseRecipient,
+  parseRecipients,
+  parseMessageInput,
+  MESSAGE_PROPERTIES,
+  messagePathType,
+  importanceRank,
+  messageValue,
+  webLink,
+  canonicalMessageSelect,
+  renderMessage,
+  FOLDER_SELECTABLE,
+  renderFolder,
+  canonicalFolderSelect,
+  folderValue,
+  folderPathType,
+  attachmentId,
+  decodeAttachmentId,
+  renderAttachment,
+  createUploadSession,
+  cancelUploadSession,
+  uploadChunk
+};
+//# sourceMappingURL=chunk-BEGIZZSN.js.map