busroot-sdk 0.0.2 → 0.0.4

package/build/busroot.d.ts

@@ -0,0 +1,816 @@
+import { z } from 'zod';
+
+declare enum RagStatus {
+  Red = "#cc3311",
+  Amber = "#ee7733",
+  Green = "#009988",
+  Blue = "#33bbee",
+  NA = "#CCCCCC",
+}
+
+declare const StationStatus = {
+  outOfShift: { label: "Out of Shift", colour: chroma("#DDDDDD") },
+  futureOutOfShift: { label: "Out of Shift (Future)", colour: chroma("#DDDDDD").darken(2) },
+  futureInShift: { label: "In Shift (Future)", colour: chroma("#DDDDDD").darken(1) },
+  noSchedule: { label: "No Schedule", colour: chroma("#ee7733") },
+  futureNoSchedule: { label: "Not Scheduled (Future)", colour: chroma("#ee7733").darken(1) },
+  nonProductionSchedule: { label: "Scheduled Non-Production", colour: chroma("#33bbee") },
+  futureNonProductionSchedule: { label: "Scheduled Non-Production (Future)", colour: chroma("#33bbee").darken(1) },
+  productionSchedule: { label: "Scheduled Production", colour: chroma("#009988") },
+  futureProductionSchedule: { label: "Scheduled Production (Future)", colour: chroma("#009988").darken(1) },
+  downtime: { label: "Unplanned Downtime", colour: chroma("#cc3311") },
+  disconnected: { label: "Connection Lost", colour: chroma("#8338ec") },
+};
+
+declare enum DowntimeType {
+  Stop = "stop",
+  Slow = "slow",
+  Manual = "manual",
+  StopUtilisation = "stop_utilisation",
+}
+
+declare enum DowntimeEventType {
+  Acknowledge = "acknowledge",
+  Estimate = "estimate",
+  Escalate = "escalate",
+  Cause = "cause",
+  Exclude = "exclude",
+}
+
+declare enum DowntimeFilterState {
+  Ongoing = "ongoing",
+  NotStartNotified = "not_start_notified",
+  NotEndNotified = "not_end_notified",
+  EscalatedOnly = "Escalated_only",
+  WithinADay = "day",
+  WithinAWeek = "week",
+  NoCause = "no_cause",
+}
+
+declare const GROUP_TAG_PREFIX = "group";
+
+declare enum MessageType {
+  intouch = "intouch",
+  kepware = "iotgateway",
+  dau = "dau",
+}
+
+declare enum PRODUCTION_TYPE {
+  MANUAL = "manual",
+  TIMESERIES = "timeseries",
+  FROM_SPEED = "from-speed",
+}
+
+declare enum SCHEDULE_TYPE {
+  NON_PRODUCTION = "non_production",
+  PRODUCTION = "production",
+}
+
+declare enum UserRole {
+  customer = "customer",
+  oi = "oi",
+  blocked = "blocked",
+  partner = "partner",
+}
+
+declare enum AccountRole {
+  member = "member",
+  admin = "admin",
+  blocked = "blocked",
+}
+
+declare enum AuthType {
+  ui = "ui",
+  api = "api",
+}
+
+declare enum WeekDay {
+  Monday = "1",
+  Tuesday = "2",
+  Wednesday = "3",
+  Thursday = "4",
+  Friday = "5",
+  Saturday = "6",
+  Sunday = "7",
+}
+
+declare enum NOTIFICATION_PREFERENCE {
+  NONE = "none",
+  ALL = "all_issues",
+  DOWNTIME_SUMMARY = "downtime_summary",
+}
+
+declare enum DOWNTIME_DETECTION_MODE {
+  OFF = "off",
+  PRODUCTION_CYCLE_TIME = "production",
+  UTILISATION = "utilisation", // TODO: Rename this to PRODUCTIVE_STATUS
+  LINE_SPEED = "line_speed",
+}
+
+declare enum PRODUCTIVE_STATUS_MODE {
+  PRODUCTIVE_SIGNAL = "productive_signal",
+  ELECTRICAL_USAGE = "electrical_usage",
+  LINE_SPEED = "line_speed",
+}
+
+declare enum TIMESERIES_MESSAGE_TYPE {
+  BAD_PRODUCTION_COMPLETE = "BAD_PRODUCTION_COMPLETE",
+  BAD_PRODUCTION_COUNT = "BAD_PRODUCTION_COUNT",
+  PRODUCTION_COMPLETE = "PRODUCTION_COMPLETE",
+  PRODUCTION_COUNT = "PRODUCTION_COUNT",
+  PRODUCTIVE = "PRODUCTIVE",
+  LINE_SPEED = "LINE_SPEED",
+  SPEED = "SPEED",
+  ELECTRICAL_KWH = "ELECTRICAL_KWH",
+  ELECTRICAL_KWH_INTERVAL = "ELECTRICAL_KWH_INTERVAL",
+  ELECTRICAL_A = "ELECTRICAL_A",
+  ELECTRICAL_V = "ELECTRICAL_V",
+  ELECTRICAL_HZ = "ELECTRICAL_HZ",
+  ELECTRICAL_KW = "ELECTRICAL_KW",
+  ELECTRICAL_PF = "ELECTRICAL_PF",
+  STATUS_CODE = "STATUS_CODE",
+  RSSI = "RSSI",
+}
+
+declare enum CursorType {
+  production = "production",
+  stops = "stops",
+  slowLineSpeed = "slow_line_speed",
+  lastStatusCode = "last_status_code",
+  stationWindows = "station_windows",
+}
+
+declare enum ALERT_ISSUE_TYPE {
+  STOP = "stop",
+  RESOLVED = "resolved",
+  ESCALATED = "escalated",
+}
+
+declare enum STATION_MODULE_VISIBILITY {
+  UTILISATION = "utilisation",
+  ELECTRICAL = "electrical",
+  LINE_SPEED = "line_speed",
+}
+
+declare enum EMAIL_HARNESS_TYPE {
+  LOGIN = "login",
+  DOWNTIME_DETECTION = "downtime_detection",
+  DAILY_SUMMARY = "daily_summary",
+  DAILY_SUMMARY_REAL_ACCOUNT = "daily_summary_real_account",
+}
+
+declare const PERFORMANCE_MODE_TYPE = {
+  cycleTime: "cycle-time",
+  unitsPerMinute: "units-per-minute",
+  unitsPerHour: "units-per-hour",
+  lineSpeed: "line-speed",
+  none: "none",
+} as const;
+
+type PERFORMANCE_MODE_TYPE = (typeof PERFORMANCE_MODE_TYPE)[keyof typeof PERFORMANCE_MODE_TYPE];
+
+declare const REASON_TYPE = {
+  downtime: "downtime",
+  non_production: "non-production",
+} as const;
+
+type REASON_TYPE = (typeof REASON_TYPE)[keyof typeof REASON_TYPE];
+
+declare const MqttEventType = {
+  StationMetricNew: "STATION_METRIC_NEW", // When a new station window is created and saved to DB.
+  StationChanged: "STATION_CHANGED", // When a station is added or edited. NOT IMPLEMENTED.
+  ScheduleChanged: "SCHEDULE_CHANGED", // When a schedule is added or edited. NOT IMPLEMENTED.
+  ScheduleStarted: "SCHEDULE_STARTED", // When a schedule starts (actualStartAt). NOT IMPLEMENTED.
+  ScheduleEnded: "SCHEDULE_ENDED", // When a schedule ends (actualEndAt). NOT IMPLEMENTED.
+  ProductionNew: "PRODUCTION_NEW", // When new production is added. NOT IMPLEMENTED FOR MANUAL PRODUCTION YET.
+};
+
+type MqttEventType = keyof typeof MqttEventType;
+
+interface BusrootSignals {
+  timestamp?: number;
+  production_complete?: number;
+  bad_production_complete?: number;
+  production_count?: number;
+  production_count_good?: number;
+  bad_production_count?: number;
+  production_count_bad?: number;
+  sku_code?: string;
+  productive?: number;
+  line_speed?: number;
+  speed?: number;
+  status_code?: string;
+  electrical_kwh?: number;
+  electrical_kwh_interval?: number;
+  electrical_v?: number;
+  electrical_a?: number;
+  electrical_kw?: number;
+  electrical_hz?: number;
+  electrical_pf?: number;
+  rssi?: number;
+}
+
+interface PlantSchema {
+  code: string;
+  name: string;
+  timezone: string;
+  accountId: string;
+  dayStartHour: number;
+  createdAt?: string;
+  updatedAt?: string;
+  archivedAt?: string;
+}
+
+declare const StationSchema = z.object({
+  // Basics
+  accountId: z.string(),
+  code: z.string().describe("Code: Assign a Code to the Station, this cannot be changed once set."),
+  name: z.string().trim().min(1).max(32).describe("Name: Assign a Name to the Station."),
+  description: z.string().nullish(),
+  groupCode: z.string().describe("Group: Assign the station to a group of stations."),
+  shiftPatternId: z.number().int().positive().nullish().describe("Shift Pattern: Select which Shift Pattern the station will follow."),
+  moduleVisibility: z.array(z.nativeEnum(STATION_MODULE_VISIBILITY)).nullish(),
+  minimumCycleTime: z
+    .number()
+    .int()
+    .gte(0)
+    .lte(TimeIntervals["12h"].ms)
+    .nullish()
+    .describe(
+      "Minimum Cycle Time (secs): Set a minimum cycle-time for the station. If more than one signal is received in this period, Busroot will only count one unit. This allows filtering of signals during setup process for example.",
+    ),
+  speedScale: z
+    .number()
+    .gte(-9999)
+    .lte(9999)
+    .nullish()
+    .describe(
+      "Speed scale: If the value on the Performance Chart doesn't reflect actual running speed, it can be calibrated by setting this value. For example current value = 20, but actual speed = 10, scale should be set to 0.5.",
+    ),
+  speedOffset: z
+    .number()
+    .gte(-9999)
+    .lte(9999)
+    .nullish()
+    .describe(
+      "Speed offset: This can be set to fine tune a Speed value. For example if a Stations speed is showing as 0.5 when stopped, set the value to -0.5.",
+    ),
+  speedToProductionRatio: z
+    .number()
+    .gte(0)
+    .lte(99999)
+    .nullish()
+    .describe(
+      "Speed to Production Ratio: A speed value can be converted into a production count. Set the conversion ratio, this can be a decimal if required. (if left blank no production units will be counted)",
+    ),
+  electricalPowerNominalKw: z
+    .number()
+    .gte(0)
+    .nullish()
+    .describe("Electrical Power Nominal (kW): The expected power usage in kW during normal operation."),
+
+  // Defaults
+  idleCostPerMinute: z
+    .number()
+    .gte(0)
+    .lte(99999)
+    .nullish()
+    .describe(
+      "Idle Cost (£/min): Assign a cost per minute for any idle time. This will be used for scheduling losses, planned non-production losses and downtime losses where the SKU does not have a value set.",
+    ),
+
+  // Downtime Settings
+  downtimeDetectionMode: z
+    .nativeEnum(DOWNTIME_DETECTION_MODE)
+    .default(DOWNTIME_DETECTION_MODE.UTILISATION)
+    .optional()
+    .describe(
+      "Downtime Detection Mode: Busroot will report downtime for a station using either Utilisation, Production Cycle data or Line Speed Monitoring. (relevant signals must be connected)",
+    ),
+  utilisationDowntimeThreshold: z
+    .preprocess((val) => (val === null ? TimeIntervals["1h"].ms : val), z.number().int().gte(0).optional())
+    .describe(
+      "Utilisation Downtime Threshold (mins): This controls the minimum period before Busroot will register downtime. ie. with a threshold of 10mins, only stops of 10 mins or longer will be recorded.",
+    ),
+
+  slowDurationThreshold: z.number().int().gte(0).nullish(),
+  forceAllShiftTimeAsPlannedProduction: z.boolean().default(true),
+
+  // Productive Settings
+  productiveStatusMode: z
+    .nativeEnum(PRODUCTIVE_STATUS_MODE)
+    .default(PRODUCTIVE_STATUS_MODE.PRODUCTIVE_SIGNAL)
+    .optional()
+    .describe("Productive Status Mode: Select one of the following to measure when the station is engaged in a value-adding-activity."),
+  electricalUsageStoppedThresholdKw: z
+    .number()
+    .gte(0)
+    .nullish()
+    .describe(
+      "Stopped Threshold (kW): Set the minimum kW consumption that indicates the station active, below this Busroot will regard as downtime.",
+    ),
+  lineSpeedStoppedThreshold: z
+    .number()
+    .gte(0)
+    .nullish()
+    .describe(
+      "Line Speed Stopped Threshold: Set the minimum speed that the indicates the station is running, below this Busroot will regard as downtime.",
+    ),
+  productiveHoldOnTime: z
+    .number()
+    .int()
+    .gte(0)
+    .lte(TimeIntervals["1d"].ms)
+    .nullish()
+    .describe(
+      "Productive Hold on Time (mins): This controls the length of time a station is considered active after a productive signal. Each time a new signal is received the hold on time will restart.",
+    ),
+
+  // Flags
+  allowInterruptionMode: z
+    .boolean()
+    .default(false)
+    .optional()
+    .describe(
+      "Allow Interruption Mode: Enable the Interruption tool. The tool provides an intuitive way to capture downtime from human-lead manufacturing processes where digital data capture is impossible.",
+    ),
+  allowManualProduction: z
+    .boolean()
+    .default(false)
+    .optional()
+    .describe(
+      "Allow Manual Production: This enables the production entry module on the tablet, allowing operators to count production manually.",
+    ),
+  allowQuickScheduleStart: z
+    .boolean()
+    .default(false)
+    .optional()
+    .describe("Allow Ad Hoc Schedules: This allows operators with tablets to start new schedules directly from the tablet."),
+  allowScheduleCutShort: z
+    .boolean()
+    .default(false)
+    .optional()
+    .describe(
+      "Allow Schedule Cut Short: This enables a button in Schedule Management, to allow a schedule to be ended early. The remaining quantity will be added to a new schedule with the same Work Order Ref.",
+    ),
+
+  // Current State
+  currentOperatorInitials: z.string().min(3).max(3).nullish(),
+  statusCode: z.string().nullish(),
+  statusCodeUpdatedAt: z.string().nullish(),
+
+  // Performance Mode
+  cycleTime: z
+    .number()
+    .int()
+    .gt(0)
+    .lte(TimeIntervals["12h"].ms)
+    .nullish()
+    .describe("Cycle Time (secs): Set a standard cycle-time for the station."),
+  unitsPerMinute: z.number().int().gt(0).nullish().describe("Units Per Minute: Set the expected production rate in units/min."),
+  unitsPerHour: z.number().int().gt(0).nullish().describe("Units Per Hour: Set the expected production rate in units/hr."),
+  lineSpeedTarget: z.number().gt(0).lte(99999).nullish().describe("Line Speed Target: Set a target speed for the station."),
+
+  // System info
+  createdAt: z.string().nullish(),
+  updatedAt: z.string().nullish(),
+  archivedAt: z.string().nullish(),
+});
+
+type StationSchema = z.infer<typeof StationSchema>;
+
+declare const AccountSchema = z.object({
+  id: z.string(),
+  domain: z.string(),
+  stationCountLimit: z.number().nullish(),
+  electricalPricePerKwh: z.number().nullish(),
+  electricalCo2PerKwh: z.number().nullish(),
+  currency: z.string().nullish(),
+  enableLostProductionCost: z.boolean().nullish(),
+  dashboardConfig: z.record(z.string(), z.any()).nullish(),
+  redshiftPassword: z.string().nullish(),
+  uploadTransforms: z.string().nullish(),
+  defaultAutoEndOnQuantityComplete: z.boolean().nullish(),
+  appUrls: z.string().nullish(),
+  createdAt: z.string().nullish(),
+  updatedAt: z.string().nullish(),
+});
+
+type AccountSchema = z.infer<typeof AccountSchema>;
+
+// OEE Availability = (scheduledProductionMs - downtimeMs) / scheduledProductionMs
+// OEE Performance = (productionTargetCount - (productionTargetCount - (productionGoodCount + productionBadCount)) / productionTargetCount
+// OEE Quality = (productionGoodCount - productionBadCount) / productionGoodCount
+
+declare const StationWindowSchema = z.object({
+  accountId: z.string().describe(""),
+  stationCode: z.string().describe("A code that uniquely identifies this station within this account."),
+  windowStartAt: z.string().describe("The start time of this window in ISO 8601 format."),
+  windowEndAt: z.string().describe("The end time of this window in ISO 8601 format."),
+  totalMs: z.number().describe("The total number milliseconds covered by this window. Shortcut for windowEndAt - windowStartAt."),
+  shiftMs: z.number().describe("The number of milliseconds that were in shift.").optional(),
+  shiftName: z.string().describe("The name of the shift at this time.").optional(),
+  scheduledProductionMs: z.number().describe("The number of milliseconds that were scheduled production.").optional(),
+  scheduledNonProductionMs: z.number().describe("The number of milliseconds that were scheduled non-production.").optional(),
+  productiveMs: z.number().describe("The number of milliseconds that the station was in a productive state.").optional(),
+  downtimeId: z.number().describe("The ID of the current downtime.").optional(),
+  downtimeMs: z.number().describe("The number of milliseconds that the station was in downtime.").optional(),
+  downtimeReasonCode: z.string().describe("The reason code assigned to the current downtime.").optional(),
+  downtimeSince: z.string().describe("The time this downtime started, in ISO 8601 format.").optional(),
+  rssiAvg: z
+    .number()
+    .optional()
+    .describe("The received signal strength of the wireless device. -70dBm to -80dBm is good. <-90dBm is bad.")
+    .optional(),
+  productionGoodCount: z.number().describe("The number of good quality units produced.").optional(),
+  productionBadCount: z.number().describe("The number of bad quality units produced.").optional(),
+  productionIdealCount: z
+    .number()
+    .optional()
+    .describe(
+      "The number of production units that should have been produced according to the SKU/part's cycle-time. WITH consideration for downtime.",
+    )
+    .optional(),
+  productionTargetCount: z
+    .number()
+    .describe(
+      "The number of production units that should have been produced according to the SKU/part's cycle-time. WITHOUT consideration for downtime.",
+    )
+    .optional(),
+  speed: z
+    .number()
+    .describe(
+      "The average line speed. Line speed is an arbitrary value that relates to this station's manufacturing process. i.e. Motor RPM.",
+    )
+    .optional(),
+  errorCode: z.string().describe("The error code that was flagged.").optional(),
+  scheduleId: z.number().describe("The ID of the current schedule.").optional(),
+  skuCode: z.string().describe("The SKU code taken from the current schedule.").optional(),
+  isAlive: z
+    .boolean()
+    .describe(
+      "A boolean value indicating if any signal was recieved from this station. Useful for detemining if the device has been disconnected from the network.",
+    )
+    .optional(),
+  electricalVoltsAvg: z.number().describe("The average voltage of the electrical supply.").optional(),
+  electricalAmpsAvg: z.number().describe("The average current draw.").optional(),
+  electricalHzAvg: z.number().describe("The average frequency of the electrical supply.").optional(),
+  electricalPfAvg: z.number().describe("The average Power Factor.").optional(),
+  electricalKwAvg: z.number().describe("The average power used.").optional(),
+  electricalKwh: z.number().describe("The total energy consumed.").optional(),
+  statusCode: z.string().describe("").optional(),
+  nonProductionReasonCode: z.string().describe("The non-production reason code for the current schedule.").optional(),
+  skuGroupCode: z.string().describe("").optional(),
+  electricalCost: z.number().describe("The cost of the electricity used.").optional(),
+  costCurrency: z.string().describe("The currency of any costs.").optional(),
+  electricalCo2: z.number().describe("The amount of CO2 associated with the electricity used.").optional(),
+  workOrderReference: z.string().describe("The work order reference of the current schedule.").optional(),
+
+  lostProductionCostNonProduction: z.number().describe("The cost of the time lost to scheduled non-production.").optional(),
+  lostProductionCostDowntime: z.number().describe("The cost of the time lost to downtime.").optional(),
+  lostProductionCostSpeed: z.number().describe("The cost of the shortfall units lost due to under performance.").optional(),
+  lostProductionCostQuality: z.number().describe("The cost of the bad quality units produced.").optional(),
+
+  // Performance Mode
+  performanceModeFrom: z.string().describe("").optional(),
+  performanceModeType: z.string().describe("").optional(),
+
+  productionGoodValue: z.number().describe("The value of the good quality units produced.").optional(),
+  productionBadValue: z.number().describe("The value of the bad quality units produced.").optional(),
+
+  createdAt: z.string().describe("").optional(),
+  updatedAt: z.string().describe("").optional(),
+});
+
+type StationWindowSchema = z.infer<typeof StationWindowSchema>;
+
+declare const ApiKeySchema = z.object({
+  accountId: z.string(),
+  key: z.string(),
+  createdByUserId: z.number(),
+  expiresAt: z.string(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+type ApiKeySchema = z.infer<typeof ApiKeySchema>;
+
+declare const AccountViewModel = AccountSchema.merge(
+  z.object({
+    cursors: z
+      .array(
+        z.object({
+          type: z.string(),
+          timestamp: z.number(),
+          value: z.string(),
+          valueAgo: z.string(),
+        }),
+      )
+      .optional(),
+    redshiftConfig: z
+      .object({
+        host: z.string(),
+        port: z.number(),
+        username: z.string(),
+      })
+      .optional(),
+  }),
+);
+
+type AccountViewModel = z.infer<typeof AccountViewModel>;
+
+declare const PlantViewModel = z.object({
+  code: z.string(),
+  name: z.string(),
+  timezone: z.string(),
+  now: z.string(),
+  stationGroups: z.array(StationGroupSchema.omit({ accountId: true })),
+  dayStartHour: z.number(),
+});
+
+type PlantViewModel = z.infer<typeof PlantViewModel>;
+
+declare const SkuViewModel = z.object({
+  code: z.string(),
+  name: z.string(),
+  cycleTime: z.number().nullish(),
+  specifications: z.object({ name: z.string(), value: z.string() }).array().nullish(),
+  instructionsUrl: z.string().nullish(),
+  lineSpeedTarget: z.number().nullish(),
+  downtimeDurationThresholdMultiplier: z.number().nullish(),
+  allowUseInQuickSchedule: z.boolean().nullish(),
+  unitsPerMinute: z.number().nullish(),
+  unitsPerHour: z.number().nullish(),
+  batchSize: z.number().nullish(),
+  value: z.number().nullish(),
+  minimumCycleTime: z.number().nullish(),
+});
+type SkuViewModel = z.infer<typeof SkuViewModel>;
+
+declare const OeeViewModel = z.object({
+  scheduleMs: z.number().describe("The number of milliseconds spent on any schedule."), // production and non-production scheduled time combined.
+  scheduleLossMs: z.number().describe("The number of milliseconds lost to unscheduled time in shift."), // The amount of in shift time not schedule in either way.
+  schedulePerc: z.number().describe("The ratio of scheduled to unscheduled time."),
+
+  productionScheduleMs: z.number().describe("The number of milliseconds spent in a production schedule."), // In simplified OEE, this is shift time minus scheduled non-production time. In full OEE, this would be only scheduled production time.
+  productionScheduleLossMs: z.number().describe("The number of milliseconds lost to non-production schedules."),
+  productionSchedulePerc: z.number().describe("The ratio of production to non-production scheduled time."),
+
+  availabilityMs: z.number().describe("The number of milliseconds spent running."), // The planned production time minus stop time.
+  availabilityLossMs: z.number().describe("The number of milliseconds spend stopped."), // The amount of time the station is stopped during planned production time ()
+  availabilityPerc: z.number().describe("The ratio of running to stopped time aka OEE Availability."),
+
+  performanceMs: z
+    .number()
+    .describe("The number of milliseconds spend producing under ideal circumstances (production count * ideal cycle time)."),
+  performanceLossMs: z.number().describe("The number of milliseconds lost to under-production vs ideal cycle times."),
+  performancePerc: z.number().describe("OEE Performance."),
+
+  goodQualityCount: z.number().describe("The number of good quality units produced."),
+  goodQualityLossCount: z.number().describe("The number of bad quality units produced."),
+  goodQualityPerc: z.number().describe("The ratio of good units to bad units aka OEE Quality."),
+
+  scheduledNonProduction: z.array(OeeStop),
+  stops: z.array(OeeStop),
+
+  oee: z.number(),
+});
+
+type OeeViewModel = z.infer<typeof OeeViewModel>;
+
+type ApiKeyViewModel = ApiKeySchema;
+
+declare const ScheduleViewModel = z.object({
+  id: z.number(),
+  stationCode: z.string(),
+  stationName: z.string().optional(),
+  accountId: z.string(),
+  plannedStartAt: z.string(),
+  plannedStartAtTimestamp: z.number(),
+  plannedEndAt: z.string().optional(),
+  plannedEndAtTimestamp: z.number().optional(),
+  workOrderReference: z.string().optional(),
+  plannedDuration: z.number().optional(),
+  plannedQuantity: z.number().optional(),
+  nonProductionReasonCode: z.string().optional(),
+  nonProductionReasonDescription: z.string().optional(),
+  skuCode: z.string().optional(),
+  skuName: z.string().optional(),
+  skuValue: z.number().optional(),
+  batchSize: z.number().optional(),
+  autoEndOnQuantityComplete: z.boolean().optional(),
+
+  cycleTime: z.number().optional(),
+  unitsPerMinute: z.number().optional(),
+  unitsPerHour: z.number().optional(),
+  lineSpeedTarget: z.number().optional(),
+
+  effectiveCycleTime: z.number().optional(),
+  effectiveUnitsPerMinute: z.number().optional(),
+  effectiveUnitsPerHour: z.number().optional(),
+  effectiveLineSpeedTarget: z.number().optional(),
+  normalisedCycleTime: z
+    .number()
+    .optional()
+    .describe("The effective performance mode, convered back into a cycle time (aka the time in millis required to make 1 unit."),
+  effectiveBatchSize: z.number().optional(),
+  effectiveMinimumCycleTime: z.number().optional(),
+
+  remainingTime: z.number().optional(),
+  quantityIdeal: z.number().optional(),
+  quantityIdealDelta: z.number().optional(),
+
+  deletedAt: z.string().optional(),
+  actualStartAt: z.string().optional(),
+  actualStartAtTimestamp: z.number().optional(),
+  actualEndAt: z.string().optional(),
+  actualEndAtTimestamp: z.number().optional(),
+  idealEndAt: z.string().optional(),
+  idealEndAtTimestamp: z.number().optional(),
+  idealDuration: z.number().optional(),
+  quantityGood: z.number().optional(),
+  quantityBad: z.number().optional(),
+  quantityTotal: z.number().optional(),
+  skuGroupCode: z.string().optional(),
+  skuGroupName: z.string().optional(),
+  extendShift: z.boolean().optional(),
+  downtimeDurationThresholdMultiplier: z.number().optional(),
+  isStarted: z.boolean(),
+  isEnded: z.boolean(),
+  status: z.enum(["running", "planned", "deleted", "completed"]),
+  allowScheduleCutShort: z.boolean().optional(),
+  performanceModeFrom: z.enum(["schedule", "sku", "station", "none"]).optional(),
+  logs: z.array(z.string()).optional(),
+  priorityAt: z.string().optional(),
+});
+
+type ScheduleViewModel = z.infer<typeof ScheduleViewModel>;
+
+declare const StationWindowViewModel = StationWindowSchema.omit({
+  skuCode: true,
+  skuGroupCode: true,
+  nonProductionReasonCode: true,
+  downtimeReasonCode: true,
+  downtimeId: true,
+  errorCode: true,
+  scheduleId: true,
+  workOrderReference: true,
+  shiftName: true,
+})
+  .required({ isAlive: true })
+  .merge(
+    z.object({
+      stationName: z.string().describe("The name of the station."),
+      scheduleIds: z.array(z.number()).describe("The IDs of the schedules that ran.").optional(),
+      workOrderReferences: z.array(z.string()).describe("The WO refs of the schedules that ran.").optional(),
+      errorCodes: z.array(z.string()).describe("The error codes that were flagged.").optional(),
+      downtimeIds: z.array(z.number()).describe("The IDs of the downtimes that occured.").optional(),
+      downtimeReasonCodes: z.array(z.string()).describe("The reason codes of the downtimes that occured.").optional(),
+      nonProductionReasonCodes: z
+        .array(z.string())
+        .optional()
+        .describe("The reason codes for the non-production schedules that ran.")
+        .optional(),
+      windowStartAtTimestamp: z.number().describe("The start time of this window as a UNIX timestamp."),
+      windowEndAtTimestamp: z.number().describe("The end time of this window as a UNIX timestamp."),
+      isFuture: z.boolean().describe("A boolean value indicating if this is a placeholder station window for future time.").optional(),
+      skuName: z.string().describe("The name of the SKU from the current schedule.").optional(),
+      skuCodes: z.array(z.string()).describe("The code of the SKUs from the schedules that ran.").optional(),
+      shiftNames: z.array(z.string()).describe("The shift names during this time.").optional(),
+      skuGroupCodes: z.array(z.string()).describe("The code of the SKU Groups from the schedules that ran.").optional(),
+      lostProductionCostTotal: z.number().describe("The total cost of lost production output.").optional(),
+      productionTotalCount: z.number().describe("The total number of units produced, both good and bad.").optional(),
+      productionRatePerHour: z.number().describe("The average rate of production in units per hour.").optional(),
+      productionRatePerHourIdeal: z.number().describe("The ideal rate of production in units per hour.").optional(),
+      productionMs: z
+        .number()
+        .describe("The number of milliseconds of actual production achieved (production count * ideal cycle time).")
+        .optional(),
+    }),
+  );
+
+type StationWindowViewModel = z.infer<typeof StationWindowViewModel>;
+
+declare const StationViewModel = z.object({
+  code: z.string(), // from station table
+  name: z.string(), // from station table
+  description: z.string().nullish(),
+  groupCode: z.string().nullish(), // from station table
+  groupName: z.string().nullish(), // from join with group table
+  allowScheduleStationFlexibility: z.boolean().nullish(), // from join with group table
+  plantCode: z.string(), // from station table
+  timezone: z.string(), // from join with plant table
+  accountId: z.string(), // from station table
+  currentOperatorInitials: z.string().nullish(), // from station table
+
+  cycleTime: z.number().nullish(), // from station table
+  unitsPerMinute: z.number().nullish(),
+  unitsPerHour: z.number().nullish(),
+  lineSpeedTarget: z.number().nullish(), // from station table
+
+  allowInterruptionMode: z.boolean().nullish(),
+  allowManualProduction: z.boolean().nullish(),
+  downtimeDetectionMode: z.nativeEnum(DOWNTIME_DETECTION_MODE), // from station table
+  utilisationDowntimeThreshold: z.number().nullish(), // from station table
+  slowDurationThreshold: z.number().nullish(), // from station table
+  electricalUsageStoppedThresholdKw: z.number().nullish(), // from station table
+  allowScheduleCutShort: z.boolean().nullish(), // from station table
+  productiveStatusMode: z.nativeEnum(PRODUCTIVE_STATUS_MODE), // from station table
+  lineSpeedStoppedThreshold: z.number().nullish(), // from station table
+  shiftPatternId: z.number().nullish(), // from station table
+  productiveHoldOnTime: z.number(), // from station table
+  minimumCycleTime: z.number().nullish(), // from station table
+  statusCode: z.string().nullish(), // from station table
+  statusCodeUpdatedAt: z.string().nullish(), // from station table
+  electricalPowerNominalKw: z.number().nullish(), // from station table
+
+  shiftPattern: ShiftPatternViewModel.optional(),
+  shifts: z.array(ShiftSchema), // from join with shift table. station.shiftPatternId or if null, stationGroup.shiftPatternId
+
+  currentShift: ShiftSchema.optional(), // the shift calculated to be in now. Null if not in any shift.
+
+  currentStopReasonCode: z.string().nullish(), // The reason code for the 'stop' type issue that is ongoing for this station. unknown if no reason given. null if no ongoing 'stop' type issue.
+  stoppedSince: z.number().nullish(), // The startAt of the ongoing 'stop' type issue. null if no ongoing issue.
+
+  // TODO: Change this to stateCode. It doesn't match our API style to return the entire state object.
+  state: StationState,
+  idleCostPerMinute: z.number().nullish(),
+  moduleVisibility: z.array(z.nativeEnum(STATION_MODULE_VISIBILITY)).nullish(),
+  cachedAt: z.number().nullish(),
+  allowQuickScheduleStart: z.boolean().nullish(),
+  speedScale: z.number().nullish(),
+  speedOffset: z.number().nullish(),
+  speedToProductionRatio: z.number().nullish(),
+
+  forceAllShiftTimeAsPlannedProduction: z.boolean(), // This will cause any in shift time to be treated as planned production time for the sake of downtime detection and OEE.
+
+  lastStationWindow: StationWindowViewModel.nullish(),
+});
+
+type StationViewModel = z.infer<typeof StationViewModel>;
+
+declare const ReliabilityData = z.object({
+  runningsCount: z.number(),
+  stopsCount: z.number(),
+  totalRunningTime: z.number(),
+  totalStoppedTime: z.number(),
+});
+
+type ReliabilityData = z.infer<typeof ReliabilityData>;
+
+declare const StationWindowViewModelTrimmed = StationWindowViewModel.omit({
+  accountId: true,
+  createdAt: true,
+  updatedAt: true,
+})
+  .partial({ stationCode: true, stationName: true })
+  .merge(
+    z.object({
+      //TODO: Reasons don't have name, they have descriptions. This needs to be updated.
+      nonProductionReasonNames: z.array(z.string()).optional(),
+    }),
+  );
+
+type StationWindowViewModelTrimmed = z.infer<typeof StationWindowViewModelTrimmed>;
+
+declare const CycleTimeAnalysis = z.object({
+  avg: z.number(),
+  min: z.number(),
+  max: z.number(),
+  quantity: z.number(),
+  default: z.number().optional(),
+  stations: z
+    .object({
+      stationCode: z.string(),
+      stationName: z.string(),
+      avg: z.number(),
+      min: z.number(),
+      max: z.number(),
+      quantity: z.number(),
+    })
+    .array(),
+});
+
+type CycleTimeAnalysis = z.infer<typeof CycleTimeAnalysis>;
+
+declare const NominalValue = z.object({
+  electricalPowerNominalKw: z.number(),
+});
+
+type NominalValue = z.infer<typeof NominalValue>;
+
+declare const AggregatedStationWindowsByStation = z.object({
+  stationCode: z.string(),
+  stationName: z.string(),
+  stationGroupCode: z.string(),
+  stationGroupName: z.string(),
+  windows: z.array(StationWindowViewModelTrimmed),
+  reliabilityData: ReliabilityData,
+  cycleTimeAnalysis: CycleTimeAnalysis.optional(),
+  oee: OeeViewModel,
+  nominal: NominalValue,
+});
+
+type AggregatedStationWindowsByStation = z.infer<typeof AggregatedStationWindowsByStation>;
+
+export { ALERT_ISSUE_TYPE, AccountRole, AccountSchema, AccountViewModel, AggregatedStationWindowsByStation, AuthType, CursorType, CycleTimeAnalysis, DOWNTIME_DETECTION_MODE, DowntimeEventType, DowntimeFilterState, DowntimeType, EMAIL_HARNESS_TYPE, GROUP_TAG_PREFIX, MessageType, MqttEventType, NOTIFICATION_PREFERENCE, NominalValue, OeeViewModel, PERFORMANCE_MODE_TYPE, PRODUCTION_TYPE, PRODUCTIVE_STATUS_MODE, PlantViewModel, REASON_TYPE, RagStatus, ReliabilityData, SCHEDULE_TYPE, STATION_MODULE_VISIBILITY, ScheduleViewModel, SkuViewModel, StationSchema, StationStatus, StationViewModel, StationWindowSchema, StationWindowViewModel, StationWindowViewModelTrimmed, TIMESERIES_MESSAGE_TYPE, UserRole, WeekDay };
+export type { ApiKeyViewModel, BusrootSignals, PlantSchema };