metrickit 0.1.2

package/dist/frontend.js

@@ -0,0 +1,752 @@
+// src/registry.ts
+import { z as z5 } from "zod";
+
+// src/schemas/time.ts
+import { z } from "zod";
+var TimeGranularitySchema = z.enum([
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+]);
+var TimeRangeSchema = z.object({
+  from: z.date().optional(),
+  to: z.date().optional()
+});
+var RequiredTimeRangeSchema = z.object({
+  from: z.date(),
+  to: z.date()
+});
+var CompareSchema = z.object({
+  compareToPrevious: z.boolean().optional().default(false)
+});
+// src/schemas/output.ts
+import { z as z2 } from "zod";
+var OutputKindSchema = z2.enum([
+  "kpi",
+  "timeseries",
+  "distribution",
+  "table",
+  "leaderboard",
+  "pivot"
+]);
+var MetricUnitSchema = z2.enum([
+  "DKK",
+  "EUR",
+  "USD",
+  "GBP",
+  "SEK",
+  "NOK",
+  "PERCENTAGE"
+]);
+var KpiOutputSchema = z2.object({
+  kind: z2.literal("kpi"),
+  value: z2.number(),
+  label: z2.string().optional(),
+  unit: MetricUnitSchema.optional(),
+  prefix: z2.string().optional(),
+  suffix: z2.string().optional(),
+  trend: z2.enum(["up", "down", "flat"]).optional()
+});
+function defineKpiOutput(output) {
+  return {
+    kind: "kpi",
+    ...output
+  };
+}
+var TimeSeriesPointSchema = z2.object({
+  ts: z2.date(),
+  value: z2.number(),
+  label: z2.string().optional()
+});
+var TimeSeriesSeriesSchema = z2.object({
+  key: z2.string(),
+  label: z2.string().optional(),
+  points: z2.array(TimeSeriesPointSchema),
+  chartType: z2.enum(["line", "bar"]).optional(),
+  axis: z2.enum(["left", "right"]).optional(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var TimeSeriesOutputSchema = z2.object({
+  kind: z2.literal("timeseries"),
+  granularity: TimeGranularitySchema,
+  series: z2.array(TimeSeriesSeriesSchema)
+});
+function defineTimeSeriesOutput(output) {
+  if (Array.isArray(output.series)) {
+    return {
+      kind: "timeseries",
+      ...output,
+      series: [...output.series]
+    };
+  }
+  return {
+    kind: "timeseries",
+    ...output,
+    series: Object.entries(output.series).map(([key, series]) => ({
+      key,
+      ...series
+    }))
+  };
+}
+var DistributionSegmentSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  value: z2.number(),
+  percent: z2.number().optional()
+});
+var DistributionChartTypeSchema = z2.enum([
+  "bar",
+  "donut",
+  "pie",
+  "funnel"
+]);
+var DistributionOutputSchema = z2.object({
+  kind: z2.literal("distribution"),
+  total: z2.number(),
+  segments: z2.array(DistributionSegmentSchema),
+  chartType: DistributionChartTypeSchema.optional()
+});
+function defineDistributionOutput(output) {
+  return {
+    kind: "distribution",
+    ...output,
+    segments: [...output.segments]
+  };
+}
+var TableColumnSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  type: z2.enum(["string", "number", "date", "boolean"]).optional(),
+  nullable: z2.boolean().optional()
+});
+var TableOutputSchema = z2.object({
+  kind: z2.literal("table"),
+  columns: z2.array(TableColumnSchema),
+  rows: z2.array(z2.record(z2.string(), z2.unknown())),
+  total: z2.number().optional()
+});
+function defineTableOutput(output) {
+  return {
+    kind: "table",
+    ...output,
+    columns: [...output.columns],
+    rows: [...output.rows]
+  };
+}
+var PivotDimensionSchema = z2.object({
+  key: z2.string(),
+  label: z2.string()
+});
+var PivotTotalsSchema = z2.object({
+  rowTotals: z2.array(z2.number()).optional(),
+  columnTotals: z2.array(z2.number()).optional(),
+  grandTotal: z2.number().optional()
+});
+function addGrandTotalMismatchIssue(ctx, totalsName, totals, grandTotal) {
+  const totalsSum = totals?.reduce((total, value) => total + value, 0);
+  if (totalsSum === undefined)
+    return;
+  if (Math.abs(totalsSum - grandTotal) <= Number.EPSILON)
+    return;
+  ctx.addIssue({
+    code: z2.ZodIssueCode.custom,
+    path: ["totals", "grandTotal"],
+    message: `grandTotal must equal the sum of ${totalsName}`
+  });
+}
+function clonePivotTotals(totals) {
+  if (!totals)
+    return;
+  return {
+    rowTotals: totals.rowTotals ? [...totals.rowTotals] : undefined,
+    columnTotals: totals.columnTotals ? [...totals.columnTotals] : undefined,
+    grandTotal: totals.grandTotal
+  };
+}
+function clonePivotCellTooltips(cellTooltips) {
+  if (!cellTooltips)
+    return;
+  return cellTooltips.map((row) => [...row]);
+}
+var PivotOutputSchema = z2.object({
+  kind: z2.literal("pivot"),
+  rowDimension: PivotDimensionSchema,
+  columnDimension: PivotDimensionSchema,
+  rows: z2.array(z2.string()),
+  columns: z2.array(z2.string()),
+  values: z2.array(z2.array(z2.number())),
+  cellTooltips: z2.array(z2.array(z2.string())).optional(),
+  totals: PivotTotalsSchema.optional()
+}).superRefine((pivot, ctx) => {
+  const rowCount = pivot.rows.length;
+  const columnCount = pivot.columns.length;
+  if (pivot.values.length !== rowCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["values"],
+      message: `Pivot values must have ${rowCount} rows`
+    });
+  }
+  for (const [rowIndex, row] of pivot.values.entries()) {
+    if (row.length !== columnCount) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["values", rowIndex],
+        message: `Pivot row ${rowIndex} must have ${columnCount} columns`
+      });
+    }
+  }
+  if (pivot.cellTooltips !== undefined) {
+    if (pivot.cellTooltips.length !== rowCount) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["cellTooltips"],
+        message: `cellTooltips must have ${rowCount} rows`
+      });
+    }
+    for (const [rowIndex, row] of pivot.cellTooltips.entries()) {
+      if (row.length !== columnCount) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["cellTooltips", rowIndex],
+          message: `cellTooltips row ${rowIndex} must have ${columnCount} columns`
+        });
+      }
+    }
+  }
+  if (pivot.totals?.rowTotals && pivot.totals.rowTotals.length !== rowCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["totals", "rowTotals"],
+      message: `rowTotals must have ${rowCount} entries`
+    });
+  }
+  if (pivot.totals?.columnTotals && pivot.totals.columnTotals.length !== columnCount) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["totals", "columnTotals"],
+      message: `columnTotals must have ${columnCount} entries`
+    });
+  }
+  if (pivot.totals?.grandTotal !== undefined) {
+    addGrandTotalMismatchIssue(ctx, "rowTotals", pivot.totals.rowTotals, pivot.totals.grandTotal);
+    addGrandTotalMismatchIssue(ctx, "columnTotals", pivot.totals.columnTotals, pivot.totals.grandTotal);
+  }
+});
+function definePivotOutput(output) {
+  return {
+    kind: "pivot",
+    ...output,
+    rows: [...output.rows],
+    columns: [...output.columns],
+    values: output.values.map((row) => [...row]),
+    cellTooltips: clonePivotCellTooltips(output.cellTooltips),
+    totals: clonePivotTotals(output.totals)
+  };
+}
+var LeaderboardItemSchema = z2.object({
+  rank: z2.number(),
+  id: z2.string(),
+  label: z2.string(),
+  value: z2.number(),
+  meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var LeaderboardOutputSchema = z2.object({
+  kind: z2.literal("leaderboard"),
+  items: z2.array(LeaderboardItemSchema),
+  total: z2.number().optional()
+});
+function defineLeaderboardOutput(output) {
+  return {
+    kind: "leaderboard",
+    ...output,
+    items: [...output.items]
+  };
+}
+function defineMetricOutput(kind, output) {
+  const handlers = {
+    kpi: () => defineKpiOutput(output),
+    timeseries: () => defineTimeSeriesOutput(output),
+    distribution: () => defineDistributionOutput(output),
+    table: () => defineTableOutput(output),
+    leaderboard: () => defineLeaderboardOutput(output),
+    pivot: () => definePivotOutput(output)
+  };
+  return handlers[kind]();
+}
+function validateOutput(kind, output) {
+  return OutputSchemaMap[kind].parse(output);
+}
+var MetricOutputSchema = z2.discriminatedUnion("kind", [
+  KpiOutputSchema,
+  TimeSeriesOutputSchema,
+  DistributionOutputSchema,
+  TableOutputSchema,
+  LeaderboardOutputSchema,
+  PivotOutputSchema
+]);
+var OutputSchemaMap = {
+  kpi: KpiOutputSchema,
+  timeseries: TimeSeriesOutputSchema,
+  distribution: DistributionOutputSchema,
+  table: TableOutputSchema,
+  leaderboard: LeaderboardOutputSchema,
+  pivot: PivotOutputSchema
+};
+var MetricExecutionCacheStatusSchema = z2.enum([
+  "hit",
+  "partialHit",
+  "miss",
+  "bypassed"
+]);
+var MetricExecutionSchema = z2.object({
+  cacheStatus: MetricExecutionCacheStatusSchema,
+  durationMs: z2.number().nonnegative(),
+  granularity: TimeGranularitySchema.optional()
+});
+var MetricResultSchema = z2.object({
+  current: MetricOutputSchema,
+  previous: MetricOutputSchema.optional(),
+  supportsTimeRange: z2.boolean(),
+  execution: MetricExecutionSchema.optional()
+});
+// src/schemas/inputs.ts
+import { z as z3 } from "zod";
+var BaseFiltersSchema = z3.object({
+  organizationIds: z3.array(z3.string()).optional()
+}).merge(TimeRangeSchema);
+var TimeSeriesFiltersSchema = z3.object({
+  organizationIds: z3.array(z3.string()).optional()
+}).merge(RequiredTimeRangeSchema);
+function extendBaseFilters(shape) {
+  const optionalShape = Object.fromEntries(Object.entries(shape).map(([key, schema]) => [
+    key,
+    schema.optional()
+  ]));
+  return BaseFiltersSchema.extend(optionalShape);
+}
+function extendTimeSeriesFilters(shape) {
+  const optionalShape = Object.fromEntries(Object.entries(shape).map(([key, schema]) => [
+    key,
+    schema.optional()
+  ]));
+  return TimeSeriesFiltersSchema.extend(optionalShape);
+}
+// src/schemas/metric-type.ts
+import { z as z4 } from "zod";
+var MetricTypeSchema = z4.enum(["TOTAL", "AVG", "PER_BUCKET"]);
+// src/define-metric.ts
+function defineMetricWithSchema(kind, outputSchema, def) {
+  return {
+    kind,
+    outputSchema,
+    ...def
+  };
+}
+function defineKpiMetric(def) {
+  return defineMetricWithSchema("kpi", KpiOutputSchema, def);
+}
+function defineTimeSeriesMetric(def) {
+  return defineMetricWithSchema("timeseries", TimeSeriesOutputSchema, def);
+}
+function defineDistributionMetric(def) {
+  return defineMetricWithSchema("distribution", DistributionOutputSchema, def);
+}
+function defineTableMetric(def) {
+  return defineMetricWithSchema("table", TableOutputSchema, def);
+}
+function defineLeaderboardMetric(def) {
+  return defineMetricWithSchema("leaderboard", LeaderboardOutputSchema, def);
+}
+function definePivotMetric(def) {
+  return defineMetricWithSchema("pivot", PivotOutputSchema, def);
+}
+function getOutputSchema(metric) {
+  return metric.outputSchema;
+}
+function validateMetricOutput(metric, output2) {
+  return getOutputSchema(metric).parse(output2);
+}
+
+// src/registry.ts
+function createRegistry(metrics, options) {
+  const metricKeys = metrics.map((m) => m.key);
+  const MetricKeySchema = z5.enum(metricKeys);
+  const MetricRequestSchema = z5.object({
+    key: MetricKeySchema,
+    requestKey: z5.string().optional(),
+    filters: z5.record(z5.string(), z5.unknown()).optional()
+  });
+  const MetricsRequestSchema = z5.object({
+    metrics: z5.array(MetricRequestSchema).min(1, "At least one metric required"),
+    granularity: TimeGranularitySchema.optional(),
+    from: z5.date().optional(),
+    to: z5.date().optional(),
+    compareToPrevious: z5.boolean().optional().default(false),
+    disableCache: z5.boolean().optional().default(false)
+  });
+  const metricsByKey = Object.fromEntries(metrics.map((metric) => [metric.key, metric]));
+  const baseFilterSchema = options?.baseFilterSchema ?? BaseFiltersSchema;
+  const kindSchemas = options?.kindSchemas ?? OutputSchemaMap;
+  function getMetricByKey(key) {
+    return metricsByKey[key];
+  }
+  function parseMetricRequestInput(metricRequest, options2) {
+    const metric = getMetricByKey(metricRequest.key);
+    if (!metric) {
+      throw new Error(`Unknown metric: ${metricRequest.key}`);
+    }
+    const baseFilters = baseFilterSchema.parse({
+      from: options2?.from,
+      to: options2?.to,
+      ...metricRequest.filters
+    });
+    return {
+      metric,
+      requestKey: getMetricResultKey(metricRequest),
+      filters: metric.filterSchema.parse(baseFilters)
+    };
+  }
+  return {
+    metrics,
+    baseFilterSchema,
+    kindSchemas,
+    metricKeys,
+    MetricKeySchema,
+    MetricRequestSchema,
+    MetricsRequestSchema,
+    metricsByKey,
+    getMetricByKey,
+    parseMetricRequestInput,
+    getOutputSchema
+  };
+}
+function getMetricResultKey(metricRequest) {
+  return metricRequest.requestKey ?? metricRequest.key;
+}
+function getMetric(result, key) {
+  return result.metrics[key];
+}
+
+// src/frontend/requests.ts
+function defineMetricRequest(request) {
+  return request;
+}
+function defineMetricsRequest(request) {
+  return request;
+}
+function getMetricResult(result, key) {
+  return result.metrics[key];
+}
+// src/frontend/stream-state.ts
+function getPendingMetricKeys(request) {
+  return request.metrics.map((metric) => getMetricResultKey(metric));
+}
+function createMetricsStreamState(request) {
+  return {
+    metrics: {},
+    errors: {},
+    status: "idle",
+    done: false,
+    receivedKeys: [],
+    pendingKeys: getPendingMetricKeys(request)
+  };
+}
+function applyMetricResultChunk(state, chunk) {
+  const streamChunk = chunk;
+  const resultKey = getMetricResultKey(streamChunk);
+  const receivedKeys = state.receivedKeys.includes(resultKey) ? state.receivedKeys : [...state.receivedKeys, resultKey];
+  const errors = streamChunk.error ? {
+    ...state.errors,
+    [resultKey]: streamChunk.error
+  } : state.errors;
+  const metrics = streamChunk.result ? {
+    ...state.metrics,
+    [resultKey]: streamChunk.result
+  } : state.metrics;
+  const nextState = {
+    ...state,
+    status: streamChunk.done ? "complete" : "streaming",
+    done: streamChunk.done,
+    receivedKeys,
+    pendingKeys: state.pendingKeys.filter((key) => key !== resultKey),
+    errors,
+    metrics
+  };
+  return nextState;
+}
+// src/frontend/catalog.ts
+function createAvailableMetricMap(metrics) {
+  return Object.fromEntries(metrics.map((metric) => [metric.key, metric]));
+}
+function getAvailableMetric(metrics, key) {
+  return metrics.find((metric) => metric.key === key);
+}
+function getMetricFilterFields(metric) {
+  return metric?.filters ?? [];
+}
+function groupAvailableMetricsByKind(metrics) {
+  const groups = {};
+  for (const metric of metrics) {
+    const kind = metric.kind;
+    const group = groups[kind] ?? [];
+    groups[kind] = [...group, metric];
+  }
+  return groups;
+}
+// src/frontend/format.ts
+var CURRENCY_UNITS = ["DKK", "EUR", "USD", "GBP", "SEK", "NOK"];
+var formatterCache = new Map;
+function getFormatter(locale, options = {}) {
+  const cacheKey = JSON.stringify([locale, options]);
+  const cached = formatterCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const formatter = new Intl.NumberFormat(locale, options);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+function formatMetricNumber(value, options = {}) {
+  return getFormatter(options.locale ?? "da-DK").format(value);
+}
+function formatMetricDecimal(value, options = {}) {
+  const safeValue = Number.isFinite(value) ? value : 0;
+  return getFormatter(options.locale ?? "da-DK", {
+    maximumFractionDigits: options.maximumFractionDigits ?? 2
+  }).format(safeValue);
+}
+function formatMetricCurrency(value, currency, options = {}) {
+  return getFormatter(options.locale ?? "da-DK", {
+    style: "currency",
+    currency: currency ?? options.defaultCurrency ?? "DKK",
+    maximumFractionDigits: options.maximumFractionDigits ?? 0
+  }).format(value);
+}
+function formatKpiValue(value, unit, prefix, suffix, options = {}) {
+  if (unit && CURRENCY_UNITS.includes(unit)) {
+    return formatMetricCurrency(value, unit, options);
+  }
+  if (unit === "PERCENTAGE") {
+    return `${value.toFixed(options.maximumFractionDigits ?? 1)}%`;
+  }
+  const formatted = formatMetricNumber(value, options);
+  const leading = prefix ?? "";
+  const trailing = suffix ? ` ${suffix}` : "";
+  return `${leading}${formatted}${trailing}`;
+}
+// src/frontend/time.ts
+function computeRangeLabel(from, to, options = {}) {
+  if (!from || !to)
+    return "";
+  const now = options.now ?? new Date;
+  const diffMs = to.getTime() - from.getTime();
+  const diffDays = Math.round(diffMs / (1000 * 60 * 60 * 24));
+  const toIsNow = Math.abs(now.getTime() - to.getTime()) < 1000 * 60 * 60 * 24;
+  if (toIsNow) {
+    if (diffDays <= 1)
+      return "Last 24 hours";
+    if (diffDays <= 7)
+      return "Last 7 days";
+    if (diffDays <= 14)
+      return "Last 14 days";
+    if (diffDays <= 30)
+      return "Last 30 days";
+    if (diffDays <= 60)
+      return "Last 60 days";
+    if (diffDays <= 90)
+      return "Last 90 days";
+    if (diffDays <= 180)
+      return "Last 6 months";
+    if (diffDays <= 365)
+      return "Last 12 months";
+    return `Last ${Math.round(diffDays / 365)} years`;
+  }
+  const locale = options.locale ?? "en-US";
+  const formatDate = (date) => date.toLocaleDateString(locale, { month: "short", day: "numeric" });
+  const fromYear = from.getFullYear();
+  const toYear = to.getFullYear();
+  if (fromYear === toYear) {
+    return `${formatDate(from)} - ${formatDate(to)}, ${fromYear}`;
+  }
+  return `${formatDate(from)}, ${fromYear} - ${formatDate(to)}, ${toYear}`;
+}
+// src/frontend/markers.ts
+var SEVERITY_COLORS = {
+  info: "#3b82f6",
+  success: "#22c55e",
+  warning: "#f59e0b",
+  danger: "#ef4444"
+};
+var LOG_TYPE_CATEGORIES = {
+  UNIT_OTHER: "Notes",
+  UNIT_USER_CREATED: "Unit Created",
+  UNIT_STATUS: "Status Changes",
+  UNIT_INIT_PRODUCTION: "Production",
+  UNIT_ASSIGNED_TO_ORGANIZATION: "Assignment",
+  UNIT_ASSIGNED_TO_WAREHOUSE: "Warehouse",
+  UNIT_REMOVED_FROM_WAREHOUSE: "Warehouse",
+  UNIT_ASSIGNED_TO_PRODUCTION: "Production",
+  UNIT_MAINTENANCE_CREATED: "Maintenance",
+  UNIT_MAINTENANCE_DONE: "Maintenance",
+  UNIT_DESTROYED: "Destroyed",
+  UNIT_CHANGE_IMSI: "IMSI Change",
+  UNIT_CHANGED_PLACEMENT_TYPE: "Placement Type"
+};
+function getMarkerTypes(markers) {
+  return Array.from(new Set(markers.map((marker) => marker.type)));
+}
+function filterChartMarkers(markers, enabledTypes) {
+  return markers.filter((marker) => enabledTypes.has(marker.type));
+}
+function getMarkerCategories(markers, enabledTypes) {
+  const counts = new Map;
+  for (const marker of markers) {
+    const existing = counts.get(marker.type);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(marker.type, { label: marker.label, count: 1 });
+    }
+  }
+  return Array.from(counts.entries()).map(([type, { label, count }]) => ({
+    type,
+    label,
+    count,
+    enabled: enabledTypes.has(type)
+  }));
+}
+function toggleMarkerType(enabledTypes, type) {
+  const next = new Set(enabledTypes);
+  if (next.has(type)) {
+    next.delete(type);
+  } else {
+    next.add(type);
+  }
+  return next;
+}
+function toggleAllMarkerTypes(markers, enabled) {
+  return enabled ? new Set(getMarkerTypes(markers)) : new Set;
+}
+function mapLogItemsToMarkers(items) {
+  return items.filter((item) => item.data != null).map((item) => ({
+    id: item.id,
+    timestamp: new Date(item.createdAt),
+    type: item.data.type,
+    label: LOG_TYPE_CATEGORIES[item.data.type] ?? item.data.type,
+    title: item.data.title,
+    description: item.data.description,
+    severity: item.data.severity,
+    icon: item.data.icon
+  }));
+}
+// src/frontend/dashboard.ts
+function defineMetricsDashboard(config) {
+  return config;
+}
+function defineWidget(keyOrConfig, config) {
+  if (typeof keyOrConfig === "string") {
+    return {
+      key: keyOrConfig,
+      ...config ?? {}
+    };
+  }
+  return keyOrConfig;
+}
+function defineHeadline(title, description) {
+  return {
+    _type: "headline",
+    title,
+    description
+  };
+}
+function defineSpacer(layout) {
+  return {
+    _type: "spacer",
+    layout
+  };
+}
+function defineCustomSlot(slotId, config) {
+  return {
+    _type: "slot",
+    slotId,
+    layout: config?.layout,
+    props: config?.props
+  };
+}
+var defaultDashboardControls = {
+  showTimeRange: true,
+  showGranularity: false,
+  showCompare: true,
+  defaultCompareToPrevious: false
+};
+// src/frontend/renderers.ts
+function defineRendererRegistry(registry) {
+  return registry;
+}
+function hasCustomRenderer(metricKey, registry) {
+  return Boolean(registry?.byMetricKey?.[metricKey]);
+}
+function resolveRendererHandle(metricKey, kind, registry) {
+  const byMetricKey = registry?.byMetricKey?.[metricKey];
+  if (byMetricKey) {
+    return {
+      rendererId: byMetricKey,
+      source: "metric",
+      metricKey,
+      kind
+    };
+  }
+  const byKind = registry?.byKind?.[kind];
+  if (byKind) {
+    return {
+      rendererId: byKind,
+      source: "kind",
+      metricKey,
+      kind
+    };
+  }
+  return {
+    rendererId: `kind:${kind}`,
+    source: "fallback",
+    metricKey,
+    kind
+  };
+}
+export {
+  toggleMarkerType,
+  toggleAllMarkerTypes,
+  resolveRendererHandle,
+  mapLogItemsToMarkers,
+  hasCustomRenderer,
+  groupAvailableMetricsByKind,
+  getMetricResultKey as getRequestedMetricKey,
+  getPendingMetricKeys,
+  getMetricResult,
+  getMetricFilterFields,
+  getMarkerTypes,
+  getMarkerCategories,
+  getAvailableMetric,
+  formatMetricNumber,
+  formatMetricDecimal,
+  formatMetricCurrency,
+  formatKpiValue,
+  filterChartMarkers,
+  defineWidget,
+  defineSpacer,
+  defineRendererRegistry,
+  defineMetricsRequest,
+  defineMetricsDashboard,
+  defineMetricRequest,
+  defineHeadline,
+  defineCustomSlot,
+  defaultDashboardControls,
+  createMetricsStreamState,
+  createAvailableMetricMap,
+  computeRangeLabel,
+  applyMetricResultChunk,
+  SEVERITY_COLORS
+};