@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/service-normalize-connector.js

@@ -0,0 +1,816 @@
+import { parseCronExpression } from "@elizaos/agent";
+import {
+  BROWSER_BRIDGE_KINDS,
+  BROWSER_BRIDGE_SITE_ACCESS_MODES,
+  BROWSER_BRIDGE_TRACKING_MODES
+} from "@elizaos/plugin-browser";
+import {
+  LIFEOPS_CONNECTOR_MODES,
+  LIFEOPS_CONNECTOR_SIDES,
+  LIFEOPS_EVENT_KINDS,
+  LIFEOPS_GOOGLE_CAPABILITIES,
+  LIFEOPS_REMINDER_CHANNELS,
+  LIFEOPS_TIME_WINDOW_NAMES,
+  LIFEOPS_WORKFLOW_TRIGGER_TYPES
+} from "../contracts/index.js";
+import {
+  resolveDefaultTimeZone,
+  resolveDefaultWindowPolicy
+} from "./defaults.js";
+import { normalizeGoogleCapabilities } from "./google-scopes.js";
+import { DEFAULT_BROWSER_PERMISSION_STATE } from "./browser-constants.js";
+import {
+  DAY_MINUTES,
+  DEFAULT_WORKFLOW_PERMISSION_POLICY
+} from "./service-constants.js";
+import {
+  fail,
+  normalizeEnumValue,
+  normalizeFiniteNumber,
+  normalizeIsoString,
+  normalizeOptionalBoolean,
+  normalizeOptionalIsoString,
+  normalizeOptionalString,
+  normalizePositiveInteger,
+  normalizeValidTimeZone,
+  requireNonEmptyString
+} from "./service-normalize.js";
+import { LifeOpsServiceError } from "./service-types.js";
+function requireRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail(400, `${field} must be an object`);
+  }
+  return { ...value };
+}
+function normalizeOptionalRecord(value, field) {
+  if (value === void 0) return void 0;
+  return requireRecord(value, field);
+}
+function mergeMetadata(current, updates) {
+  const cloned = updates && typeof updates === "object" && !Array.isArray(updates) ? { ...updates } : {};
+  const merged = {
+    ...current,
+    ...cloned
+  };
+  if (typeof merged.privacyClass !== "string" || merged.privacyClass.trim().length === 0) {
+    merged.privacyClass = "private";
+  }
+  if (merged.privacyClass === "private") {
+    merged.publicContextBlocked = true;
+  }
+  return merged;
+}
+function normalizedStringSet(values) {
+  return [
+    ...new Set(values.map((value) => value.trim()).filter(Boolean))
+  ].sort();
+}
+function normalizeOptionalConnectorMode(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  return normalizeEnumValue(value, field, LIFEOPS_CONNECTOR_MODES);
+}
+function normalizeOptionalConnectorSide(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  return normalizeEnumValue(value, field, LIFEOPS_CONNECTOR_SIDES);
+}
+function normalizeGoogleCapabilityRequest(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    fail(400, "capabilities must be an array");
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of value) {
+    const capability = normalizeEnumValue(
+      candidate,
+      "capabilities[]",
+      LIFEOPS_GOOGLE_CAPABILITIES
+    );
+    if (seen.has(capability)) {
+      continue;
+    }
+    seen.add(capability);
+    normalized.push(capability);
+  }
+  return normalizeGoogleCapabilities(normalized);
+}
+function normalizeGrantCapabilities(capabilities) {
+  return normalizeGoogleCapabilities(capabilities);
+}
+function normalizeWorkflowTriggerType(value) {
+  return normalizeEnumValue(
+    value,
+    "triggerType",
+    LIFEOPS_WORKFLOW_TRIGGER_TYPES
+  );
+}
+function normalizeWorkflowSchedule(value, triggerType) {
+  if (triggerType === "manual") {
+    return { kind: "manual" };
+  }
+  const schedule = requireRecord(value, "schedule");
+  if (triggerType === "event") {
+    return normalizeEventTrigger(schedule);
+  }
+  const kind = normalizeEnumValue(schedule.kind, "schedule.kind", [
+    "once",
+    "interval",
+    "cron",
+    "relative_to_wake",
+    "relative_to_bedtime",
+    "during_morning",
+    "during_night"
+  ]);
+  if (kind === "once") {
+    return {
+      kind,
+      runAt: normalizeIsoString(schedule.runAt, "schedule.runAt"),
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone")
+    };
+  }
+  if (kind === "interval") {
+    return {
+      kind,
+      everyMinutes: normalizePositiveInteger(
+        schedule.everyMinutes,
+        "schedule.everyMinutes"
+      ),
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone")
+    };
+  }
+  const regularityAtLeast = schedule.requireRegularityAtLeast === void 0 || schedule.requireRegularityAtLeast === null ? void 0 : normalizeEnumValue(
+    schedule.requireRegularityAtLeast,
+    "schedule.requireRegularityAtLeast",
+    [
+      "very_regular",
+      "regular",
+      "irregular",
+      "very_irregular",
+      "insufficient_data"
+    ]
+  );
+  if (kind === "relative_to_wake") {
+    return {
+      kind,
+      offsetMinutes: normalizeOptionalInteger(
+        schedule.offsetMinutes,
+        "schedule.offsetMinutes"
+      ) ?? 0,
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone"),
+      onDays: normalizeOptionalWeekdays(schedule.onDays, "schedule.onDays"),
+      requireRegularityAtLeast: regularityAtLeast,
+      stabilityWindowMinutes: normalizeOptionalInteger(
+        schedule.stabilityWindowMinutes,
+        "schedule.stabilityWindowMinutes"
+      ) ?? void 0
+    };
+  }
+  if (kind === "relative_to_bedtime") {
+    return {
+      kind,
+      offsetMinutes: normalizeOptionalInteger(
+        schedule.offsetMinutes,
+        "schedule.offsetMinutes"
+      ) ?? 0,
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone"),
+      onDays: normalizeOptionalWeekdays(schedule.onDays, "schedule.onDays"),
+      requireRegularityAtLeast: regularityAtLeast
+    };
+  }
+  if (kind === "during_morning") {
+    return {
+      kind,
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone"),
+      windowMinutesFromWake: normalizeOptionalInteger(
+        schedule.windowMinutesFromWake,
+        "schedule.windowMinutesFromWake"
+      ) ?? void 0,
+      onDays: normalizeOptionalWeekdays(schedule.onDays, "schedule.onDays"),
+      requireRegularityAtLeast: regularityAtLeast
+    };
+  }
+  if (kind === "during_night") {
+    return {
+      kind,
+      timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone"),
+      windowMinutesBeforeSleepTarget: normalizeOptionalInteger(
+        schedule.windowMinutesBeforeSleepTarget,
+        "schedule.windowMinutesBeforeSleepTarget"
+      ) ?? void 0,
+      onDays: normalizeOptionalWeekdays(schedule.onDays, "schedule.onDays"),
+      requireRegularityAtLeast: regularityAtLeast
+    };
+  }
+  const cronExpression = requireNonEmptyString(
+    schedule.cronExpression,
+    "schedule.cronExpression"
+  );
+  if (!parseCronExpression(cronExpression)) {
+    fail(
+      400,
+      "schedule.cronExpression must be a valid 5-field cron expression"
+    );
+  }
+  return {
+    kind,
+    cronExpression,
+    timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone")
+  };
+}
+function normalizeEventTrigger(schedule) {
+  const kind = normalizeEnumValue(schedule.kind, "schedule.kind", [
+    "event"
+  ]);
+  const eventKind = normalizeEnumValue(
+    schedule.eventKind,
+    "schedule.eventKind",
+    LIFEOPS_EVENT_KINDS
+  );
+  const rawFilters = schedule.filters;
+  if (rawFilters === void 0 || rawFilters === null) {
+    return { kind, eventKind };
+  }
+  const filtersRecord = requireRecord(rawFilters, "schedule.filters");
+  if (eventKind === "calendar.event.ended") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "calendar.event.ended",
+        filters: normalizeCalendarEventEndedFilters(filtersRecord)
+      }
+    };
+  }
+  if (eventKind === "lifeops.wake.observed") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.wake.observed",
+        filters: normalizeWakeEventFilters(filtersRecord, "schedule.filters")
+      }
+    };
+  }
+  if (eventKind === "lifeops.wake.confirmed") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.wake.confirmed",
+        filters: normalizeWakeEventFilters(filtersRecord, "schedule.filters")
+      }
+    };
+  }
+  if (eventKind === "lifeops.sleep.onset_candidate") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.sleep.onset_candidate",
+        filters: normalizeMinConfidenceFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "lifeops.sleep.detected") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.sleep.detected",
+        filters: normalizeMinConfidenceFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "lifeops.sleep.ended") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.sleep.ended",
+        filters: normalizeMinConfidenceFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "lifeops.nap.detected") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.nap.detected",
+        filters: normalizeMinConfidenceFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "lifeops.bedtime.imminent") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.bedtime.imminent",
+        filters: normalizeBedtimeImminentFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "lifeops.regularity.changed") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: "lifeops.regularity.changed",
+        filters: normalizeRegularityChangedFilters(
+          filtersRecord,
+          "schedule.filters"
+        )
+      }
+    };
+  }
+  if (eventKind === "gmail.message.received" || eventKind === "gmail.thread.needs_response") {
+    return {
+      kind,
+      eventKind,
+      filters: {
+        kind: eventKind,
+        filters: normalizeGmailEventFilters(filtersRecord)
+      }
+    };
+  }
+  return { kind, eventKind };
+}
+function normalizeOptionalInteger(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const numeric = normalizeFiniteNumber(value, field);
+  if (!Number.isInteger(numeric)) {
+    fail(400, `${field} must be an integer`);
+  }
+  return numeric;
+}
+function normalizeOptionalConfidence(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const confidence = normalizeFiniteNumber(value, field);
+  if (confidence < 0 || confidence > 1) {
+    fail(400, `${field} must be between 0 and 1`);
+  }
+  return confidence;
+}
+function normalizeOptionalWeekdays(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array of weekday numbers`);
+  }
+  const weekdays = [];
+  for (const candidate of value) {
+    const weekday = normalizeFiniteNumber(candidate, `${field}[]`);
+    if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) {
+      fail(400, `${field}[] must be an integer between 0 and 6`);
+    }
+    weekdays.push(weekday);
+  }
+  return [...new Set(weekdays)].sort((left, right) => left - right);
+}
+function normalizeWakeEventFilters(input, field) {
+  return {
+    offsetMinutes: normalizeOptionalInteger(
+      input.offsetMinutes,
+      `${field}.offsetMinutes`
+    ),
+    minConfidence: normalizeOptionalConfidence(
+      input.minConfidence,
+      `${field}.minConfidence`
+    )
+  };
+}
+function normalizeMinConfidenceFilters(input, field) {
+  return {
+    minConfidence: normalizeOptionalConfidence(
+      input.minConfidence,
+      `${field}.minConfidence`
+    )
+  };
+}
+function normalizeBedtimeImminentFilters(input, field) {
+  return {
+    minutesBefore: normalizeOptionalInteger(
+      input.minutesBefore,
+      `${field}.minutesBefore`
+    ),
+    minConfidence: normalizeOptionalConfidence(
+      input.minConfidence,
+      `${field}.minConfidence`
+    )
+  };
+}
+const REGULARITY_CLASS_VALUES = /* @__PURE__ */ new Set([
+  "very_regular",
+  "regular",
+  "irregular",
+  "very_irregular",
+  "insufficient_data"
+]);
+function normalizeRegularityChangedFilters(input, field) {
+  if (input.becomes === void 0 || input.becomes === null) {
+    return {};
+  }
+  const value = input.becomes;
+  if (typeof value !== "string" || !REGULARITY_CLASS_VALUES.has(value)) {
+    throw new Error(
+      `${field}.becomes must be one of ${[...REGULARITY_CLASS_VALUES].join(", ")}`
+    );
+  }
+  return { becomes: value };
+}
+function normalizeCalendarEventEndedFilters(input) {
+  const filters = {};
+  if (input.calendarIds !== void 0) {
+    filters.calendarIds = normalizeStringArray(
+      input.calendarIds,
+      "schedule.filters.calendarIds"
+    );
+  }
+  if (input.titleIncludesAny !== void 0) {
+    filters.titleIncludesAny = normalizeStringArray(
+      input.titleIncludesAny,
+      "schedule.filters.titleIncludesAny"
+    );
+  }
+  if (input.minDurationMinutes !== void 0) {
+    filters.minDurationMinutes = normalizePositiveInteger(
+      input.minDurationMinutes,
+      "schedule.filters.minDurationMinutes"
+    );
+  }
+  if (input.attendeeEmailIncludesAny !== void 0) {
+    filters.attendeeEmailIncludesAny = normalizeStringArray(
+      input.attendeeEmailIncludesAny,
+      "schedule.filters.attendeeEmailIncludesAny"
+    );
+  }
+  return filters;
+}
+function normalizeGmailEventFilters(input) {
+  const filters = {};
+  if (input.grantIds !== void 0) {
+    filters.grantIds = normalizeStringArray(
+      input.grantIds,
+      "schedule.filters.grantIds"
+    );
+  }
+  if (input.fromIncludesAny !== void 0) {
+    filters.fromIncludesAny = normalizeStringArray(
+      input.fromIncludesAny,
+      "schedule.filters.fromIncludesAny"
+    );
+  }
+  if (input.subjectIncludesAny !== void 0) {
+    filters.subjectIncludesAny = normalizeStringArray(
+      input.subjectIncludesAny,
+      "schedule.filters.subjectIncludesAny"
+    );
+  }
+  if (input.labelIds !== void 0) {
+    filters.labelIds = normalizeStringArray(
+      input.labelIds,
+      "schedule.filters.labelIds"
+    );
+  }
+  if (input.requiresReplyNeeded !== void 0) {
+    filters.requiresReplyNeeded = normalizeOptionalBoolean(
+      input.requiresReplyNeeded,
+      "schedule.filters.requiresReplyNeeded"
+    );
+  }
+  return filters;
+}
+function normalizeStringArray(value, field) {
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array of strings`);
+  }
+  const out = [];
+  for (const entry of value) {
+    out.push(requireNonEmptyString(entry, `${field}[]`));
+  }
+  return out;
+}
+function normalizeWorkflowPermissionPolicy(value, current = DEFAULT_WORKFLOW_PERMISSION_POLICY) {
+  if (value === void 0) {
+    return { ...current };
+  }
+  const input = requireRecord(value, "permissionPolicy");
+  return {
+    allowBrowserActions: normalizeOptionalBoolean(
+      input.allowBrowserActions,
+      "permissionPolicy.allowBrowserActions"
+    ) ?? current.allowBrowserActions,
+    trustedBrowserActions: normalizeOptionalBoolean(
+      input.trustedBrowserActions,
+      "permissionPolicy.trustedBrowserActions"
+    ) ?? current.trustedBrowserActions,
+    allowXPosts: normalizeOptionalBoolean(
+      input.allowXPosts,
+      "permissionPolicy.allowXPosts"
+    ) ?? current.allowXPosts,
+    trustedXPosting: normalizeOptionalBoolean(
+      input.trustedXPosting,
+      "permissionPolicy.trustedXPosting"
+    ) ?? current.trustedXPosting,
+    requireConfirmationForBrowserActions: normalizeOptionalBoolean(
+      input.requireConfirmationForBrowserActions,
+      "permissionPolicy.requireConfirmationForBrowserActions"
+    ) ?? current.requireConfirmationForBrowserActions,
+    requireConfirmationForXPosts: normalizeOptionalBoolean(
+      input.requireConfirmationForXPosts,
+      "permissionPolicy.requireConfirmationForXPosts"
+    ) ?? current.requireConfirmationForXPosts
+  };
+}
+function normalizeOptionalBrowserKind(value, field) {
+  const browser = normalizeOptionalString(value);
+  if (!browser) {
+    return null;
+  }
+  return normalizeEnumValue(browser, field, BROWSER_BRIDGE_KINDS);
+}
+function normalizeBrowserPermissionStateInput(value, current = DEFAULT_BROWSER_PERMISSION_STATE) {
+  if (value === void 0) {
+    return { ...current, grantedOrigins: [...current.grantedOrigins] };
+  }
+  const input = requireRecord(value, "permissions");
+  const grantedOrigins = input.grantedOrigins;
+  return {
+    tabs: normalizeOptionalBoolean(input.tabs, "permissions.tabs") ?? current.tabs,
+    scripting: normalizeOptionalBoolean(input.scripting, "permissions.scripting") ?? current.scripting,
+    activeTab: normalizeOptionalBoolean(input.activeTab, "permissions.activeTab") ?? current.activeTab,
+    allOrigins: normalizeOptionalBoolean(input.allOrigins, "permissions.allOrigins") ?? current.allOrigins,
+    grantedOrigins: grantedOrigins === void 0 ? [...current.grantedOrigins] : normalizeBrowserPermissionGrantList(
+      grantedOrigins,
+      "permissions.grantedOrigins"
+    ),
+    incognitoEnabled: normalizeOptionalBoolean(
+      input.incognitoEnabled,
+      "permissions.incognitoEnabled"
+    ) ?? current.incognitoEnabled
+  };
+}
+function normalizeOrigin(value, field) {
+  const text = requireNonEmptyString(value, field);
+  let parsed;
+  try {
+    parsed = new URL(text);
+  } catch {
+    fail(400, `${field} must be a valid origin URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    fail(400, `${field} must use http or https`);
+  }
+  return parsed.origin;
+}
+function normalizeBrowserPermissionGrant(value, field) {
+  const text = requireNonEmptyString(value, field);
+  const isHostPermissionPattern = /^(?:https?|file|ftp|chrome-extension|moz-extension):\/\/\S+$/i.test(text);
+  if (text === "<all_urls>") {
+    return text;
+  }
+  if (isHostPermissionPattern && (text.includes("*") || !/^(?:https?):\/\//i.test(text))) {
+    return text;
+  }
+  try {
+    return normalizeOrigin(text, field);
+  } catch (error) {
+    if (!(error instanceof LifeOpsServiceError) || error.status !== 400) {
+      throw error;
+    }
+  }
+  if (isHostPermissionPattern) {
+    return text;
+  }
+  fail(
+    400,
+    `${field} must be a valid origin URL or browser host-permission pattern`
+  );
+}
+function normalizeBrowserPermissionGrantList(value, field) {
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array`);
+  }
+  return normalizedStringSet(
+    value.map(
+      (candidate, index) => normalizeBrowserPermissionGrant(candidate, `${field}[${index}]`)
+    )
+  );
+}
+function normalizeOriginList(value, field) {
+  if (!Array.isArray(value)) {
+    fail(400, `${field} must be an array`);
+  }
+  return normalizedStringSet(
+    value.map(
+      (candidate, index) => normalizeOrigin(candidate, `${field}[${index}]`)
+    )
+  );
+}
+function normalizeBrowserSettingsUpdate(request, current) {
+  return {
+    enabled: normalizeOptionalBoolean(request.enabled, "enabled") ?? current.enabled,
+    trackingMode: request.trackingMode === void 0 ? current.trackingMode : normalizeEnumValue(
+      request.trackingMode,
+      "trackingMode",
+      BROWSER_BRIDGE_TRACKING_MODES
+    ),
+    allowBrowserControl: normalizeOptionalBoolean(
+      request.allowBrowserControl,
+      "allowBrowserControl"
+    ) ?? current.allowBrowserControl,
+    requireConfirmationForAccountAffecting: normalizeOptionalBoolean(
+      request.requireConfirmationForAccountAffecting,
+      "requireConfirmationForAccountAffecting"
+    ) ?? current.requireConfirmationForAccountAffecting,
+    incognitoEnabled: normalizeOptionalBoolean(request.incognitoEnabled, "incognitoEnabled") ?? current.incognitoEnabled,
+    siteAccessMode: request.siteAccessMode === void 0 ? current.siteAccessMode : normalizeEnumValue(
+      request.siteAccessMode,
+      "siteAccessMode",
+      BROWSER_BRIDGE_SITE_ACCESS_MODES
+    ),
+    grantedOrigins: request.grantedOrigins === void 0 ? [...current.grantedOrigins] : normalizeOriginList(request.grantedOrigins, "grantedOrigins"),
+    blockedOrigins: request.blockedOrigins === void 0 ? [...current.blockedOrigins] : normalizeOriginList(request.blockedOrigins, "blockedOrigins"),
+    maxRememberedTabs: request.maxRememberedTabs === void 0 ? current.maxRememberedTabs : (() => {
+      const value = Math.trunc(
+        normalizeFiniteNumber(
+          request.maxRememberedTabs,
+          "maxRememberedTabs"
+        )
+      );
+      if (value < 1 || value > 50) {
+        fail(400, "maxRememberedTabs must be between 1 and 50");
+      }
+      return value;
+    })(),
+    pauseUntil: request.pauseUntil === void 0 ? current.pauseUntil : normalizeOptionalIsoString(request.pauseUntil, "pauseUntil") ?? null,
+    metadata: request.metadata === void 0 ? current.metadata : mergeMetadata(
+      current.metadata,
+      normalizeOptionalRecord(request.metadata, "metadata")
+    ),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeWindowPolicyInput(value, field, timeZone) {
+  if (value === void 0 || value === null) {
+    return resolveDefaultWindowPolicy(timeZone);
+  }
+  const input = requireRecord(value, field);
+  if (!Array.isArray(input.windows) || input.windows.length === 0) {
+    fail(400, `${field}.windows must contain at least one window`);
+  }
+  const policyTimeZone = normalizeValidTimeZone(
+    input.timezone,
+    `${field}.timezone`,
+    timeZone
+  );
+  const seenNames = /* @__PURE__ */ new Set();
+  const windows = input.windows.map((candidate, index) => {
+    const windowInput = requireRecord(candidate, `${field}.windows[${index}]`);
+    const name = normalizeEnumValue(
+      windowInput.name,
+      `${field}.windows[${index}].name`,
+      LIFEOPS_TIME_WINDOW_NAMES
+    );
+    if (seenNames.has(name)) {
+      fail(400, `${field}.windows contains duplicate name "${name}"`);
+    }
+    seenNames.add(name);
+    const label = requireNonEmptyString(
+      windowInput.label,
+      `${field}.windows[${index}].label`
+    );
+    const startMinute = Math.trunc(
+      normalizeFiniteNumber(
+        windowInput.startMinute,
+        `${field}.windows[${index}].startMinute`
+      )
+    );
+    const endMinute = Math.trunc(
+      normalizeFiniteNumber(
+        windowInput.endMinute,
+        `${field}.windows[${index}].endMinute`
+      )
+    );
+    if (startMinute < 0 || startMinute >= DAY_MINUTES * 2) {
+      fail(
+        400,
+        `${field}.windows[${index}].startMinute must be between 0 and 2879`
+      );
+    }
+    if (endMinute <= startMinute || endMinute > DAY_MINUTES * 2) {
+      fail(
+        400,
+        `${field}.windows[${index}].endMinute must be greater than startMinute and at most 2880`
+      );
+    }
+    return {
+      name,
+      label,
+      startMinute,
+      endMinute
+    };
+  });
+  return {
+    timezone: policyTimeZone,
+    windows
+  };
+}
+function normalizeQuietHoursInput(value, field) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  const input = requireRecord(value, field);
+  if (Object.keys(input).length === 0) {
+    return {};
+  }
+  const timezone = normalizeValidTimeZone(
+    input.timezone,
+    `${field}.timezone`,
+    resolveDefaultTimeZone()
+  );
+  const startMinute = Math.trunc(
+    normalizeFiniteNumber(input.startMinute, `${field}.startMinute`)
+  );
+  const endMinute = Math.trunc(
+    normalizeFiniteNumber(input.endMinute, `${field}.endMinute`)
+  );
+  if (startMinute < 0 || startMinute >= DAY_MINUTES) {
+    fail(400, `${field}.startMinute must be between 0 and 1439`);
+  }
+  if (endMinute < 0 || endMinute >= DAY_MINUTES) {
+    fail(400, `${field}.endMinute must be between 0 and 1439`);
+  }
+  let channels;
+  if (input.channels !== void 0) {
+    if (!Array.isArray(input.channels)) {
+      fail(400, `${field}.channels must be an array`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    channels = [];
+    for (const [index, candidate] of input.channels.entries()) {
+      const channel = normalizeEnumValue(
+        candidate,
+        `${field}.channels[${index}]`,
+        LIFEOPS_REMINDER_CHANNELS
+      );
+      if (seen.has(channel)) {
+        continue;
+      }
+      seen.add(channel);
+      channels.push(channel);
+    }
+  }
+  return {
+    timezone,
+    startMinute,
+    endMinute,
+    ...channels !== void 0 ? { channels } : {}
+  };
+}
+export {
+  normalizeBrowserPermissionGrant,
+  normalizeBrowserPermissionGrantList,
+  normalizeBrowserPermissionStateInput,
+  normalizeBrowserSettingsUpdate,
+  normalizeGoogleCapabilityRequest,
+  normalizeGrantCapabilities,
+  normalizeOptionalBrowserKind,
+  normalizeOptionalConnectorMode,
+  normalizeOptionalConnectorSide,
+  normalizeOrigin,
+  normalizeOriginList,
+  normalizeQuietHoursInput,
+  normalizeWindowPolicyInput,
+  normalizeWorkflowPermissionPolicy,
+  normalizeWorkflowSchedule,
+  normalizeWorkflowTriggerType
+};
+//# sourceMappingURL=service-normalize-connector.js.map