Types

import type {
  ComponentSize,
  ButtonVariant,
  ColorVariant,
  Status,
  ApiResponse,
} from '@tetherto/mdk-react-devkit/core'

type ComponentSize = 'sm' | 'md' | 'lg'

type ButtonSize = ComponentSize | 'icon'

type BorderRadius = 'none' | 'small' | 'medium' | 'large' | 'full'

type ColorVariant =
  | 'default'
  | 'primary'
  | 'secondary'
  | 'success'
  | 'warning'
  | 'error'
  | 'info'

type StatusVariant = 'success' | 'processing' | 'error' | 'warning' | 'default' | 'idle'

type ComponentColor = 'default' | 'primary' | 'success' | 'warning' | 'error'

type Position = 'top' | 'right' | 'bottom' | 'left'

type TextAlign = 'left' | 'center' | 'right' | 'justify'

type FlexAlign = 'start' | 'center' | 'end'

type ButtonVariant =
  | 'primary'
  | 'secondary'
  | 'danger'
  | 'tertiary'
  | 'link'
  | 'icon'
  | 'outline'
  | 'ghost'

type ButtonIconPosition = 'left' | 'right'

type NotificationVariant = 'success' | 'error' | 'warning' | 'info'

type BadgeStatus = 'success' | 'processing' | 'error' | 'warning' | 'default'

type TypographyColor = 'default' | 'primary' | 'success' | 'warning' | 'error' | 'muted'

type UnknownRecord = Record<string, unknown>

type Nullable<T> = T | null
type Optional<T> = T | undefined
type Maybe<T> = T | null | undefined

type Status = 'idle' | 'loading' | 'success' | 'error'

type PaginationParams = {
  limit?: number
  offset?: number
  page?: number
}

type PaginatedResponse<T> = {
  data: T[]
  page: number
  total: number
  totalPages: number
}

type ApiResponse<T> = {
  data: T
  message?: string
  status: number
}

type ApiError = {
  error: string
  message: string
  status: number
  data?: {
    message?: string
  }
}

import type {
  DataTableColumnDef,
  DataTableExpandedState,
  DataTablePaginationState,
  DataTableRow,
  DataTableRowSelectionState,
  DataTableSortingState,
} from '@tetherto/mdk-react-devkit/core'

type ValueUnit = {
  value: number | string | null
  unit: string
  realValue: number
}

type HashrateUnit = ValueUnit
type CurrencyUnit = ValueUnit

type UnitLabel = 'decimal' | 'k' | 'M' | 'G' | 'T' | 'P'

type TimeRangeFormatted = {
  start: string
  end: string
  formatted: string
}

type TimeInterval = {
  start: number
  end: number
}

type ChartLegendPosition = 'top' | 'bottom' | 'left' | 'right' | 'center' | 'chartArea'

type WeightedAverageResult = {
  avg: number
  totalWeight: number
  weightedValue: number
}

type ErrorWithTimestamp = {
  msg?: string
  message?: string
  timestamp?: number | string
}

import type {
  Alert,
  Device,
  DeviceLast,
  DeviceInfo,
  ContainerSnap,
  ContainerStats,
  MinerStats,
  MinerConfig,
  SettingsUser,
  PermLevel,
  GlobalConfig,
  TimelineChartDataPoint,
  TimelineChartDataset,
  TimelineChartData,
  ChartRange,
  AxisTitleText,
  MetricsEfficiencyLogEntry,
} from '@tetherto/mdk-react-devkit/foundation'

type Alert = {
  id?: string
  severity: string
  createdAt: number | string
  name: string
  description: string
  message?: string
  uuid?: string
  code?: string | number
  [key: string]: unknown
}

type LogFormattedAlertData = {
  title: string
  subtitle: string
  status: string
  severityLevel: number
  creationDate: number | string
  body: string
  id: string
  uuid?: string
  [key: string]: unknown
}

type Device = {
  id: string
  type: string
  tags?: string[]
  rack?: string
  last?: DeviceLast
  username?: string
  info?: DeviceInfo
  containerId?: string
  address?: string | null
  code?: string
  alerts?: Alert[] | null
  powerMeters?: Device[]
  tempSensors?: Device[]
  transformerTempSensor?: Device
  rootTempSensor?: Device
  [key: string]: unknown
}

type DeviceLast = {
  err?: string | null
  type?: string
  snap?: ContainerSnap
  alerts?: Alert[] | null
  [key: string]: unknown
}

type DeviceInfo = {
  container?: string
  pos?: string
  poolConfig?: string
  serialNum?: string
  macAddress?: string | null
  posHistory?: Partial<PosHistoryEntry[]>
  [key: string]: unknown
}

type PosHistoryEntry = {
  container: string
  pos: string
  removedAt: number
}

type DeviceData = {
  id: string
  type: string
  tags?: string[]
  rack?: string
  snap: ContainerSnap
  alerts?: Alert[]
  username?: string
  info?: DeviceInfo
  containerId?: string
  address?: string
  err?: string
  [key: string]: unknown
}

type Container = {
  info?: Partial<ContainerInfo>
  last?: Partial<ContainerLast>
} & Device

type ContainerInfo = {
  container: string
  cooling_system: Record<string, unknown>
  cdu: Record<string, unknown>
  primary_supply_temp: number
  second_supply_temp1: number
  second_supply_temp2: number
  supply_liquid_temp: number
  supply_liquid_set_temp: number
  supply_liquid_pressure: number
  return_liquid_pressure: number
}

type ContainerPosInfo = {
  containerInfo: Partial<{ container: string; type: string }>
  pdu: string | number
  socket: string | number
  pos: string
  [key: string]: unknown
}

type ContainerLast = {
  snap: {
    stats?: Partial<ContainerStats>
  }
  alerts: unknown[] | null
  err: string | null
}

type ContainerSnap = {
  stats?: Partial<ContainerStats>
  config?: Record<string, unknown>
}

type ContainerStats = {
  status: string
  ambient_temp_c: number
  humidity_percent: number
  power_w: number
  container_specific: Partial<ContainerSpecific>
  distribution_box1_power_w: number
  distribution_box2_power_w: number
  stats: Record<string, unknown>
  temperature_c: Partial<StatsTemperatureC>
  frequency_mhz: Partial<StatsFrequencyMhz>
  miner_specific: Partial<MinerSpecificStats>
  [key: string]: unknown
}

type ContainerSpecific = {
  pdu_data: Partial<ContainerPduData>[]
  [key: string]: unknown
}

type ContainerPduData = {
  power_w: number
  status: number
}

type StatsTemperatureC = {
  avg: number
  min: number
  max: number
  chips: TempChipData[]
  [key: string]: unknown
}

type StatsFrequencyMhz = {
  avg: number
  chips: ChipData[]
  [key: string]: unknown
}

type ChipData = {
  index: number
  current: number
}

type TempChipData = {
  index: number
  max?: number
  min?: number
  avg?: number
}

type MinerSpecificStats = {
  upfreq_speed: number
  [key: string]: unknown
}

type MinerStats = {
  status?: string
  uptime_ms?: number
  power_w?: number
  hashrate_mhs?: MinerHashrateMhs
  poolHashrate?: string
  temperature_c?: { max?: number }
}

type MinerHashrateMhs = {
  t_5m?: number
}

type MinerInfo = {
  container?: string
  pos?: string
  macAddress?: string
  serialNum?: string
}

type MinerConfig = {
  firmware_ver?: string
  power_mode?: string
  led_status?: boolean
}

type MinerDeviceSnapshot = {
  last?: { snap?: { config?: MinerConfig } }
}

type MinerRecord = {
  id?: string
  shortCode?: string
  info?: MinerInfo
  address?: string
  type?: string
  alerts?: unknown[]
  stats?: MinerStats
  config?: MinerConfig
  device?: MinerDeviceSnapshot
  error?: string
  err?: string
  isPoolStatsEnabled?: boolean
}

type PowerMeter = {
  last?: {
    snap?: {
      stats?: {
        power_w?: number
      }
    }
  }
}

type LvCabinetRecord = {
  id: string
  powerMeters?: PowerMeter[]
}

type GlobalConfig = {
  nominalSiteHashrate_MHS?: number
  nominalAvailablePowerMWh?: number
  nominalPowerConsumption_MW?: number
  nominalWeightedAvgEfficiency_WThs?: number
  nominalMinerCapacity?: number
  isAutoSleepAllowed?: boolean
  siteEnergyDataThresholdMWh?: number
  [key: string]: unknown
}

type TimelineChartDataPoint = {
  x: [number, number]
  y: string | undefined
}

type TimelineChartDataset = {
  label: string
  data: TimelineChartDataPoint[]
  borderColor?: string[]
  backgroundColor?: string[]
  color?: string
}

type TimelineChartData = {
  labels: string[]
  datasets: TimelineChartDataset[]
}

type ChartRange = {
  min: Date | number
  max: Date | number
}

type AxisTitleText = {
  x: string
  y: string
}

type MetricsEfficiencyLogEntry = {
  ts: number
  efficiencyWThs: number
}

type MetricsEfficiencySummary = {
  avgEfficiencyWThs: number | null
}

type SettingsUser = {
  id: string
  name?: string
  email: string
  role: string
  last_login?: string
  lastActive?: string
  [key: string]: unknown
}

type RoleOption = {
  label: string
  value: string
}

type PermLevel = 'rw' | 'r' | false

type RolesPermissionsData = {
  permissions: Record<string, Record<string, PermLevel>>
  labels: Record<string, string>
}

type SettingsExportData<TExtra extends Record<string, unknown> = Record<string, unknown>> = {
  headerControls?: Record<string, boolean>
  featureFlags?: Record<string, boolean>
  timestamp?: string
  version?: string
} & TExtra

type ImportResult = {
  success: boolean
  applied?: string[]
  errors?: string[]
  message?: string
}