@oneuptime/common 14.0.1 → 14.0.3

package/Types/Rum/UserFlow.ts

@@ -0,0 +1,187 @@
+import {
+  readDtoBoolean,
+  readDtoNumber,
+  readDtoString,
+} from "./SessionReplayApi";
+
+/*
+ * Wire contract for the User Flows page:
+ * POST /telemetry/rum/session-replay/user-flow.
+ *
+ * The endpoint answers with the ordered page JOURNEY of each recorded
+ * session in the window, not with a finished graph. Every view on the page -
+ * the flow map from the session start, the paths into or out of one page,
+ * grouping /product/8842 as /product/:id, hiding a page, filtering to
+ * frustrated sessions - is then a pure fold over the same journeys
+ * (Common/Utils/Rum/UserFlow.ts), so a control change re-draws instantly
+ * instead of re-running a ClickHouse read.
+ *
+ * Pages travel as a dictionary: `pages` holds each distinct scrubbed URL
+ * once and a journey is a list of indexes into it. A few thousand sessions
+ * share a few dozen pages, so this is what keeps the response small.
+ */
+
+/*
+ * Newest sessions read per request. The journeys of this many sessions fit
+ * in a response of a few hundred kilobytes, and a flow map drawn from them
+ * is already stable; the response says when the window held more.
+ */
+export const USER_FLOW_DEFAULT_MAX_SESSIONS: number = 5000;
+export const USER_FLOW_MAX_SESSIONS: number = 10000;
+
+/*
+ * Pages kept per journey. A session that navigates more than this is still
+ * counted; its tail is dropped. Far more than any flow map draws.
+ */
+export const USER_FLOW_MAX_PAGES_PER_JOURNEY: number = 100;
+
+/* One recorded session, reduced to what the flow map needs. */
+export interface UserFlowSessionDto {
+  sessionId: string;
+  startUnixMs: number;
+  durationMs: number;
+  deviceType: string;
+  browserName: string;
+  countryCode: string;
+  /* Session totals, from the header. */
+  errorCount: number;
+  frustrationCount: number;
+  /*
+   * The pages visited, in order, as indexes into the response's `pages`.
+   * A page repeated back to back (a reload, a chunk boundary) appears once;
+   * a return to a page after another one appears again.
+   */
+  pages: Array<number>;
+  /*
+   * Where the session's errors and frustration signals happened, as
+   * [pageIndex, errorCount, frustrationCount]. Attributed to the page a
+   * recording chunk was flushed from, so it is per page, never per visit.
+   * Pages with nothing to report are left out.
+   */
+  pageSignals: Array<[number, number, number]>;
+}
+
+export interface UserFlowJourneysResponseDto {
+  /* Distinct scrubbed page URLs ("https://shop.example.com/cart"). */
+  pages: Array<string>;
+  /* Newest first. */
+  sessions: Array<UserFlowSessionDto>;
+  /* Recorded sessions that started in the window. */
+  sessionsInWindow: number;
+  /* True when sessionsInWindow is larger than the sessions returned. */
+  isSampled: boolean;
+  maxSessions: number;
+  startUnixMs: number;
+  endUnixMs: number;
+}
+
+function readIndexArray(value: unknown, pageCount: number): Array<number> {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const indexes: Array<number> = [];
+
+  for (const entry of value) {
+    const index: number = Number(entry);
+
+    if (Number.isInteger(index) && index >= 0 && index < pageCount) {
+      indexes.push(index);
+    }
+  }
+
+  return indexes;
+}
+
+function readSignalTriples(
+  value: unknown,
+  pageCount: number,
+): Array<[number, number, number]> {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const triples: Array<[number, number, number]> = [];
+
+  for (const entry of value) {
+    if (!Array.isArray(entry) || entry.length < 3) {
+      continue;
+    }
+
+    const index: number = Number(entry[0]);
+    const errors: number = Number(entry[1]);
+    const frustration: number = Number(entry[2]);
+
+    if (!Number.isInteger(index) || index < 0 || index >= pageCount) {
+      continue;
+    }
+
+    triples.push([
+      index,
+      Number.isFinite(errors) && errors > 0 ? errors : 0,
+      Number.isFinite(frustration) && frustration > 0 ? frustration : 0,
+    ]);
+  }
+
+  return triples;
+}
+
+/*
+ * Parses the endpoint's JSON without trusting it: an index outside the
+ * dictionary is dropped rather than rendered as "undefined", and every
+ * number is coerced because ClickHouse quotes 64-bit integers.
+ */
+export function readUserFlowJourneysResponse(
+  value: unknown,
+): UserFlowJourneysResponseDto {
+  const row: Record<string, unknown> =
+    value && typeof value === "object"
+      ? (value as Record<string, unknown>)
+      : {};
+
+  const pages: Array<string> = Array.isArray(row["pages"])
+    ? (row["pages"] as Array<unknown>).map((page: unknown): string => {
+        return typeof page === "string" ? page : String(page ?? "");
+      })
+    : [];
+
+  const sessions: Array<UserFlowSessionDto> = [];
+
+  if (Array.isArray(row["sessions"])) {
+    for (const entry of row["sessions"] as Array<unknown>) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+
+      const session: Record<string, unknown> = entry as Record<string, unknown>;
+      const sessionId: string = readDtoString(session, "sessionId");
+
+      if (!sessionId) {
+        continue;
+      }
+
+      sessions.push({
+        sessionId: sessionId,
+        startUnixMs: readDtoNumber(session, "startUnixMs"),
+        durationMs: readDtoNumber(session, "durationMs"),
+        deviceType: readDtoString(session, "deviceType"),
+        browserName: readDtoString(session, "browserName"),
+        countryCode: readDtoString(session, "countryCode"),
+        errorCount: readDtoNumber(session, "errorCount"),
+        frustrationCount: readDtoNumber(session, "frustrationCount"),
+        pages: readIndexArray(session["pages"], pages.length),
+        pageSignals: readSignalTriples(session["pageSignals"], pages.length),
+      });
+    }
+  }
+
+  return {
+    pages: pages,
+    sessions: sessions,
+    sessionsInWindow: readDtoNumber(row, "sessionsInWindow"),
+    isSampled: readDtoBoolean(row, "isSampled"),
+    maxSessions: readDtoNumber(row, "maxSessions"),
+    startUnixMs: readDtoNumber(row, "startUnixMs"),
+    endUnixMs: readDtoNumber(row, "endUnixMs"),
+  };
+}

package/Types/Rum/WebVitals.ts

@@ -1,6 +1,12 @@
 export interface WebVitalDefinition {
   key: string;
   label: string;
+  /*
+   * What the vital measures, in words a non-specialist can act on. The
+   * Good / Poor limits are not repeated here - describeWebVitalThresholds
+   * derives them from `thresholds`, so the two cannot disagree.
+   */
+  description: string;
   unit: "ms" | "score";
   thresholds: { warn: number; danger: number };
   names: Array<string>;
@@ -11,6 +17,8 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   {
     key: "lcp",
     label: "Largest Contentful Paint",
+    description:
+      "How long until the biggest image or block of text on screen has rendered - roughly when the page looks loaded to the visitor.",
     unit: "ms",
     thresholds: { warn: 2500, danger: 4000 },
     names: [
@@ -23,6 +31,8 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   {
     key: "inp",
     label: "Interaction to Next Paint",
+    description:
+      "How quickly the page reacts to clicks, taps and key presses: the delay before the screen visibly updates, for close to the slowest interaction on the page.",
     unit: "ms",
     thresholds: { warn: 200, danger: 500 },
     names: [
@@ -35,6 +45,8 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   {
     key: "cls",
     label: "Cumulative Layout Shift",
+    description:
+      "How much the page jumps around while it loads - content moving under the visitor's cursor or finger. A score, not a time: lower is better and 0 means nothing moved.",
     unit: "score",
     thresholds: { warn: 0.1, danger: 0.25 },
     names: [
@@ -47,6 +59,8 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   {
     key: "fcp",
     label: "First Contentful Paint",
+    description:
+      "How long until the first text or image appears, so the visitor can see the page has started loading.",
     unit: "ms",
     thresholds: { warn: 1800, danger: 3000 },
     names: [
@@ -59,6 +73,8 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   {
     key: "ttfb",
     label: "Time to First Byte",
+    description:
+      "How long the browser waited for the first byte of the page from your server, including redirects, looking up the address and connecting.",
     unit: "ms",
     thresholds: { warn: 800, danger: 1800 },
     names: [
@@ -69,3 +85,39 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
     ],
   },
 ];
+
+// A threshold the way a person would say it: "2.5 s", "800 ms", "0.1".
+export function formatWebVitalThreshold(
+  value: number,
+  unit: WebVitalDefinition["unit"],
+): string {
+  if (unit === "score") {
+    return String(value);
+  }
+
+  if (value < 1000) {
+    return `${value} ms`;
+  }
+
+  return `${Number((value / 1000).toFixed(2))} s`;
+}
+
+/*
+ * The Good / Poor limits in words, matching how the overview rates a value:
+ * below `warn` is Good, at or above `danger` is Poor, and anything between
+ * needs work.
+ */
+export function describeWebVitalThresholds(
+  definition: Pick<WebVitalDefinition, "unit" | "thresholds">,
+): string {
+  const warn: string = formatWebVitalThreshold(
+    definition.thresholds.warn,
+    definition.unit,
+  );
+  const danger: string = formatWebVitalThreshold(
+    definition.thresholds.danger,
+    definition.unit,
+  );
+
+  return `Good below ${warn}; poor at ${danger} or more.`;
+}

package/Types/Runbook/RunbookStepType.ts

@@ -6,6 +6,14 @@ enum RunbookStepType {
   AI = "AI",
   SSH = "SSH",
   Kubernetes = "Kubernetes",
+  /*
+   * A single kubectl command, dispatched as an argv (never a shell line) to
+   * a Runner that can reach the cluster — the in-cluster Runner installed by
+   * the kubernetes-agent chart, or any Runner holding a Kubernetes
+   * credential. Composed only by OneUptime AI (investigations run read-only
+   * commands, remediations run policy-tiered writes); not authored in runbooks.
+   */
+  Kubectl = "Kubectl",
 }
 
 export default RunbookStepType;
@@ -28,6 +36,7 @@ export const RUNNER_EXECUTED_STEP_TYPES: Array<RunbookStepType> = [
   RunbookStepType.Bash,
   RunbookStepType.SSH,
   RunbookStepType.Kubernetes,
+  RunbookStepType.Kubectl,
 ];
 
 export function isRunnerExecutedStepType(type: RunbookStepType): boolean {
@@ -51,6 +60,7 @@ export function isRunnerExecutedStepType(type: RunbookStepType): boolean {
 export const PAYLOAD_CARRYING_STEP_TYPES: Array<RunbookStepType> = [
   RunbookStepType.SSH,
   RunbookStepType.Kubernetes,
+  RunbookStepType.Kubectl,
 ];
 
 export function isPayloadCarryingStepType(type: RunbookStepType): boolean {

package/Types/Runbook/RunnerJobOrigin.ts

@@ -8,6 +8,11 @@
  *                auto-executed under an operator allowlist or human-approved
  *                as part of a command plan). Claimable only by Runners with
  *                canRunAiCommands.
+ * AiInvestigation: a READ-ONLY kubectl command an AI investigation runs to
+ *                inspect a cluster it was given access to (the cluster's AI
+ *                page). Never changes anything; the policy is enforced at
+ *                enqueue and again inside the Runner. Claimable only by
+ *                Runners with canRunAiCommands.
  *
  * Rows created before this enum existed were backfilled to Runbook by the
  * AddAiCommandRemediation migration, so the column is NOT NULL.
@@ -15,6 +20,16 @@
 enum RunnerJobOrigin {
   Runbook = "Runbook",
   AiRemediation = "AiRemediation",
+  AiInvestigation = "AiInvestigation",
 }
 
+/*
+ * The origins a Runner may claim once the project granted it the AI-command
+ * capability. Kept in one place so the ingress and the Runner agree.
+ */
+export const AI_COMMAND_JOB_ORIGINS: Array<RunnerJobOrigin> = [
+  RunnerJobOrigin.AiRemediation,
+  RunnerJobOrigin.AiInvestigation,
+];
+
 export default RunnerJobOrigin;

package/Types/SecurityEvent/Connectors/SecurityEventConnectorCatalog.ts

@@ -84,6 +84,10 @@ export interface SecurityEventConnectorDefinition {
   productName: string;
   description: string;
   category: SecurityEventConnectorCategory;
+  /*
+   * The product's only mark beside its name in the Add connection picker
+   * and the Connections empty state, so no two providers share one.
+   */
   icon: IconProp;
   // Docs path under /docs, e.g. "/docs/integrations/microsoft-sentinel".
   docsPath: string;
@@ -376,7 +380,7 @@ export const SecurityEventConnectorCatalog: Array<SecurityEventConnectorDefiniti
       description:
         "Import detection alerts from Elastic Security through the Kibana detections API as Detection Finding events.",
       category: "SIEM",
-      icon: IconProp.ShieldCheck,
+      icon: IconProp.Database,
       docsPath: "/docs/integrations/elastic-security",
       defaultPollIntervalInMinutes: 5,
       supportsAlertingOnlyToggle: false,
@@ -522,7 +526,7 @@ export const SecurityEventConnectorCatalog: Array<SecurityEventConnectorDefiniti
       description:
         "Import Google SecOps (Chronicle) alerts and rule detections as Detection Finding events.",
       category: "SIEM",
-      icon: IconProp.ShieldCheck,
+      icon: IconProp.ViewfinderCircle,
       docsPath: "/docs/integrations/google-secops",
       defaultPollIntervalInMinutes: 5,
       supportsAlertingOnlyToggle: true,

package/Types/StatusPage/MergedDowntimeTotals.ts

@@ -0,0 +1,17 @@
+/*
+ * What MonitorStatusTimelineService.getMergedDowntimeSeconds returns for a
+ * SET of monitors - a monitor group, a status page group, the whole page.
+ * Both figures are unions, so an instant counts once however many of the
+ * monitors it covers.
+ *
+ * Kept here rather than next to the query because the status page's browser
+ * reads it too: the overview payload carries one per monitor group (see
+ * MonitorGroupMergedDowntimeUtil), and a monitor group's uptime percentage
+ * is measured from it.
+ */
+export interface MergedDowntimeTotals {
+  // Seconds at least one of the monitors was recorded, in any status.
+  coveredSeconds: number;
+  // Seconds at least one of them spent in a downtime status.
+  downtimeSeconds: number;
+}

package/Types/StatusPage/PublicNoteSubscriberNotificationDefault.ts

@@ -0,0 +1,148 @@
+/*
+ * An event can start without notifying status page subscribers: an incident
+ * declared with the "Notify Status Page Subscribers" box unticked (or as a
+ * private incident), an incident episode created with its notify setting off,
+ * or a scheduled maintenance event created with "Event Created: Notify Status
+ * Page Subscribers" unticked. Its subscribers were not told it started, so a
+ * public note posted on it afterwards should not be what tells them - unless
+ * whoever posts the note asks for that.
+ *
+ * So a new public note on such an event starts with "notify subscribers" off.
+ * This only moves the default: a caller that says yes or no explicitly is
+ * always obeyed.
+ *
+ * Everything here is shared by the dashboard, which sets the checkbox's
+ * starting value, and the server, which fills in the choice for notes posted
+ * without one (Slack, Microsoft Teams, workflows, the API). That way the two
+ * cannot drift apart.
+ */
+
+export interface IncidentSubscriberNotificationSetting {
+  shouldStatusPageSubscribersBeNotifiedOnIncidentCreated?:
+    | boolean
+    | null
+    | undefined;
+}
+
+export interface IncidentEpisodeSubscriberNotificationSetting {
+  shouldStatusPageSubscribersBeNotifiedOnEpisodeCreated?:
+    | boolean
+    | null
+    | undefined;
+}
+
+export interface ScheduledMaintenanceSubscriberNotificationSetting {
+  shouldStatusPageSubscribersBeNotifiedOnEventCreated?:
+    | boolean
+    | null
+    | undefined;
+}
+
+export interface ScheduledMaintenanceStateChangeSubscriberNotificationSetting
+  extends ScheduledMaintenanceSubscriberNotificationSetting {
+  shouldStatusPageSubscribersBeNotifiedWhenEventChangedToOngoing?:
+    | boolean
+    | null
+    | undefined;
+  shouldStatusPageSubscribersBeNotifiedWhenEventChangedToEnded?:
+    | boolean
+    | null
+    | undefined;
+}
+
+// The state a scheduled maintenance event is being moved to.
+export interface ScheduledMaintenanceTargetState {
+  isOngoingState?: boolean | null | undefined;
+  isEndedState?: boolean | null | undefined;
+  isResolvedState?: boolean | null | undefined;
+}
+
+export default class PublicNoteSubscriberNotificationDefault {
+  // Shown under the checkbox when it starts unticked for this reason.
+  public static readonly quietIncidentDescription: string =
+    "Unticked by default because status page subscribers were not notified when this incident was declared.";
+
+  public static readonly quietIncidentEpisodeDescription: string =
+    "Unticked by default because status page subscribers were not notified when this episode was created.";
+
+  public static readonly quietScheduledMaintenanceDescription: string =
+    "Unticked by default because status page subscribers were not notified when this scheduled maintenance event was created.";
+
+  /*
+   * Only an explicit "no" on the parent event turns the default off. An
+   * unknown setting (the event not loaded, or a row from before the setting
+   * existed) keeps the long-standing default of notifying.
+   */
+  public static shouldNotifyForSetting(
+    notifiedWhenEventStarted: boolean | null | undefined,
+  ): boolean {
+    return notifiedWhenEventStarted !== false;
+  }
+
+  public static shouldNotifyForIncident(
+    incident: IncidentSubscriberNotificationSetting | null | undefined,
+  ): boolean {
+    return PublicNoteSubscriberNotificationDefault.shouldNotifyForSetting(
+      incident?.shouldStatusPageSubscribersBeNotifiedOnIncidentCreated,
+    );
+  }
+
+  public static shouldNotifyForIncidentEpisode(
+    episode: IncidentEpisodeSubscriberNotificationSetting | null | undefined,
+  ): boolean {
+    return PublicNoteSubscriberNotificationDefault.shouldNotifyForSetting(
+      episode?.shouldStatusPageSubscribersBeNotifiedOnEpisodeCreated,
+    );
+  }
+
+  public static shouldNotifyForScheduledMaintenance(
+    scheduledMaintenance:
+      | ScheduledMaintenanceSubscriberNotificationSetting
+      | null
+      | undefined,
+  ): boolean {
+    return PublicNoteSubscriberNotificationDefault.shouldNotifyForSetting(
+      scheduledMaintenance?.shouldStatusPageSubscribersBeNotifiedOnEventCreated,
+    );
+  }
+
+  /*
+   * A state change on a scheduled maintenance event tells subscribers about
+   * the change itself, and the event has its own settings for two of them:
+   * "Event Ongoing" and "Event Ended". Moving the event into one of those
+   * states by hand starts with notifying on whenever the event is set to
+   * announce that change - the automatic change would have announced it -
+   * even if the event was created quietly. Any other change follows the
+   * created setting, like a public note. An event that notified subscribers
+   * when it was created keeps notifying by default, as before.
+   */
+  public static shouldNotifyForScheduledMaintenanceStateChange(
+    scheduledMaintenance:
+      | ScheduledMaintenanceStateChangeSubscriberNotificationSetting
+      | null
+      | undefined,
+    targetState: ScheduledMaintenanceTargetState | null | undefined,
+  ): boolean {
+    if (
+      PublicNoteSubscriberNotificationDefault.shouldNotifyForScheduledMaintenance(
+        scheduledMaintenance,
+      )
+    ) {
+      return true;
+    }
+
+    if (targetState?.isOngoingState) {
+      return PublicNoteSubscriberNotificationDefault.shouldNotifyForSetting(
+        scheduledMaintenance?.shouldStatusPageSubscribersBeNotifiedWhenEventChangedToOngoing,
+      );
+    }
+
+    if (targetState?.isEndedState || targetState?.isResolvedState) {
+      return PublicNoteSubscriberNotificationDefault.shouldNotifyForSetting(
+        scheduledMaintenance?.shouldStatusPageSubscribersBeNotifiedWhenEventChangedToEnded,
+      );
+    }
+
+    return false;
+  }
+}

package/Types/StatusPage/UptimeDailyAggregate.ts

@@ -107,4 +107,19 @@ export interface UptimeDailyAggregate {
    * false. Null when the whole window is covered.
    */
   completeFrom: Date | null;
+
+  /*
+   * The IANA zone the day buckets were cut in. Absent means UTC, which is
+   * what the server has always used when nobody asked for a zone.
+   *
+   * A client MUST draw its day bars on these same boundaries. The status page
+   * payload is one cached response shared by every visitor, so its buckets
+   * are UTC days - but the bars used to be drawn on the VISITOR's local days
+   * and a bucket was matched to whichever local day its start fell in. West
+   * of UTC that is the previous local day: every bar showed the next day's
+   * reading, and today's bar had no reading at all, so it fell back to the
+   * capped timeline rows and could come out grey. East of UTC, today's bar
+   * had no reading for the first hours of every local day.
+   */
+  timezone?: string | undefined;
 }

package/Types/Telemetry/TelemetryIngestSurface.ts

@@ -27,6 +27,13 @@ enum TelemetryIngestSurface {
   SecurityEvents = "security-events",
   Grpc = "grpc",
   Mqtt = "mqtt",
+  /*
+   * The in-cluster Runner the kubernetes-agent chart installs registers
+   * itself with the project's ingestion key — one flag on the chart, no
+   * dashboard steps. Server keys only: a browser must never be able to
+   * mint a Runner credential.
+   */
+  KubernetesAgentRunner = "kubernetes-agent-runner",
 }
 
 /*
@@ -72,6 +79,8 @@ const INGEST_SURFACE_READABLE_NAMES: Record<TelemetryIngestSurface, string> = {
   [TelemetryIngestSurface.SecurityEvents]: "security event ingest",
   [TelemetryIngestSurface.Grpc]: "gRPC ingest",
   [TelemetryIngestSurface.Mqtt]: "MQTT ingest",
+  [TelemetryIngestSurface.KubernetesAgentRunner]:
+    "Kubernetes agent Runner registration",
 };
 
 type GetIngestSurfaceReadableNameFunction = (

package/Types/Timezone.ts

@@ -94,6 +94,7 @@ enum Timezone {
   AmericaCayman = "America/Cayman",
   AmericaChicago = "America/Chicago",
   AmericaChihuahua = "America/Chihuahua",
+  AmericaCiudad_Juarez = "America/Ciudad_Juarez",
   AmericaCoral_Harbour = "America/Coral_Harbour",
   AmericaCordoba = "America/Cordoba",
   AmericaCosta_Rica = "America/Costa_Rica",
@@ -174,6 +175,7 @@ enum Timezone {
   AmericaNorth_DakotaBeulah = "America/North_Dakota/Beulah",
   AmericaNorth_DakotaCenter = "America/North_Dakota/Center",
   AmericaNorth_DakotaNew_Salem = "America/North_Dakota/New_Salem",
+  AmericaNuuk = "America/Nuuk",
   AmericaOjinaga = "America/Ojinaga",
   AmericaPanama = "America/Panama",
   AmericaPangnirtung = "America/Pangnirtung",
@@ -300,6 +302,7 @@ enum Timezone {
   AsiaPontianak = "Asia/Pontianak",
   AsiaPyongyang = "Asia/Pyongyang",
   AsiaQatar = "Asia/Qatar",
+  AsiaQostanay = "Asia/Qostanay",
   AsiaQyzylorda = "Asia/Qyzylorda",
   AsiaRangoon = "Asia/Rangoon",
   AsiaRiyadh = "Asia/Riyadh",
@@ -446,6 +449,7 @@ enum Timezone {
   EuropeKaliningrad = "Europe/Kaliningrad",
   EuropeKiev = "Europe/Kiev",
   EuropeKirov = "Europe/Kirov",
+  EuropeKyiv = "Europe/Kyiv",
   EuropeLisbon = "Europe/Lisbon",
   EuropeLjubljana = "Europe/Ljubljana",
   EuropeLondon = "Europe/London",
@@ -540,6 +544,7 @@ enum Timezone {
   PacificGuam = "Pacific/Guam",
   PacificHonolulu = "Pacific/Honolulu",
   PacificJohnston = "Pacific/Johnston",
+  PacificKanton = "Pacific/Kanton",
   PacificKiritimati = "Pacific/Kiritimati",
   PacificKosrae = "Pacific/Kosrae",
   PacificKwajalein = "Pacific/Kwajalein",