export enum AddressFamily {
  IPv4 = 2,
  IPv6 = 10,
}

export type IPAddress = number[] // Array of byte values

export enum ConfigSource {
  Static = 'static',
  Foreign = 'foreign',
  DHCPv4 = 'DHCPv4',
  DHCPv6 = 'DHCPv6',
  DHCPPD = 'DHCP-PD',
  NDisc = 'NDisc',
}

export enum ConfigState {
  Configured = 'configured',
}

export enum ScopeString {
  Host = 'host',
  Link = 'link',
  Global = 'global',
}

export enum ProtocolString {
  Kernel = 'kernel',
  Boot = 'boot',
}

export enum TypeString {
  Local = 'local',
  Broadcast = 'broadcast',
  Unicast = 'unicast',
  Anycast = 'anycast',
  Multicast = 'multicast',
  Unreachable = 'unreachable',
  Table = 'table',
}

export enum TableString {
  Local = 'local',
  Main = 'main',
  Default = 'default',
}

export type TableStringType = TableString | string

export enum AdministrativeState {
  Unmanaged = 'unmanaged',
  Configured = 'configured',
}

export enum OperationalState {
  Carrier = 'carrier',
  Routable = 'routable',
  Enslaved = 'enslaved',
  NoCarrier = 'no-carrier',
  Degraded = 'degraded',
}

export enum CarrierState {
  Carrier = 'carrier',
  Enslaved = 'enslaved',
  NoCarrier = 'no-carrier',
  DegradedCarrier = 'degraded-carrier',
}

export enum AddressState {
  Off = 'off',
  Routable = 'routable',
  Degraded = 'degraded',
}

export enum OnlineState {
  Online = 'online',
  Offline = 'offline',
}

export enum ActivationPolicy {
  Up = 'up',
}

export enum DNSEnabled {
  Yes = 'yes',
  No = 'no',
}

export enum InterfaceType {
  Loopback = 'loopback',
  Ether = 'ether',
  Bridge = 'bridge',
  Vlan = 'vlan',
  None = 'none',
}

export interface DNS {
  Family: AddressFamily
  Address: IPAddress
  ConfigSource: ConfigSource
  ConfigProvider?: IPAddress
}

export interface DNSSetting {
  LLMNR?: DNSEnabled
  MDNS?: DNSEnabled
  ConfigSource: ConfigSource
}

export interface InterfaceAddress {
  Family: AddressFamily
  Address: IPAddress
  PrefixLength: number
  ConfigSource: ConfigSource
  ConfigProvider?: IPAddress
  Scope?: number
  ScopeString?: ScopeString
  Flags: number
  FlagsString: string | null
  Broadcast?: IPAddress
  PreferredLifetimeUSec?: number
  PreferredLifetimeUsec?: number // Note: both variants exist
  ValidLifetimeUSec?: number
  ValidLifetimeUsec?: number // Note: both variants exist
  ConfigState?: ConfigState
}

export interface InterfaceRoute {
  Family: AddressFamily
  Destination: IPAddress
  DestinationPrefixLength: number
  Gateway?: IPAddress
  PreferredSource?: IPAddress
  TOS: number
  Scope: number
  Protocol: number
  Type: number
  Priority: number
  Table: number
  Flags: number
  NextHopID?: number
  ConfigSource: ConfigSource
  ConfigProvider?: IPAddress
  ScopeString: ScopeString
  ProtocolString: ProtocolString | string
  TypeString: TypeString | string
  TableString: TableStringType
  Preference: number
  FlagsString: string
  ConfigState?: ConfigState
  LifetimeUSec?: number
}

export interface NextHop {
  ID: number
  Family: AddressFamily
  ConfigSource: ConfigSource
  ConfigProvider: IPAddress
  Gateway: IPAddress
  Flags: number
  FlagsString: string
  Protocol: number
  ProtocolString: string
  Blackhole: boolean
  ConfigState?: ConfigState
}

export interface DHCPv4Lease {
  LeaseTimestampUSec: number
  Timeout1USec: number
  Timeout2USec: number
}

export interface DHCPv4Client {
  Lease: DHCPv4Lease
  ClientIdentifier: number[]
}

export interface DHCPv6Prefix {
  Prefix: IPAddress
  PrefixLength: number
  PreferredLifetimeUSec: number
  ValidLifetimeUSec: number
}

export interface DHCPv6Lease {
  Timeout1USec: number
  Timeout2USec: number
  LeaseTimestampUSec: number
}

export interface DHCPv6Client {
  Lease: DHCPv6Lease
  Prefixes: DHCPv6Prefix[]
  DUID: number[]
}

export interface DHCPLease {
  ClientId: number[]
  Address: IPAddress
  Hostname?: string
  HardwareAddressType: number
  HardwareAddressLength: number
  HardwareAddress: IPAddress
  ExpirationUSec: number
  ExpirationRealtimeUSec: number
}

export interface StaticLease {
  ClientId: number[]
  Address: IPAddress
  HardwareAddressType: number
  HardwareAddressLength: number
  HardwareAddress: IPAddress
}

export interface DHCPServer {
  PoolOffset: number
  PoolSize: number
  Leases?: DHCPLease[]
  StaticLeases?: StaticLease[]
}

export interface NetworkInterface {
  Index: number
  Name: string
  Kind?: string
  Type: InterfaceType
  Driver?: string
  Flags: number
  FlagsString: string
  KernelOperationalState: number
  KernelOperationalStateString: string
  MTU: number
  MinimumMTU: number
  MaximumMTU: number
  HardwareAddress?: IPAddress
  PermanentHardwareAddress?: IPAddress
  BroadcastAddress?: IPAddress
  IPv6LinkLocalAddress?: IPAddress
  MasterInterfaceIndex?: number
  AdministrativeState: AdministrativeState
  OperationalState: OperationalState
  CarrierState: CarrierState
  AddressState: AddressState
  IPv4AddressState: AddressState
  IPv6AddressState: AddressState
  OnlineState?: OnlineState
  NetworkFile?: string
  NetworkFileDropins?: string[]
  RequiredForOnline?: boolean
  RequiredFamilyForOnline?: 'any'
  ActivationPolicy?: ActivationPolicy
  LinkFile?: string
  NetDevFile?: string
  NetDevFileDropins?: string[]
  Path?: string
  Vendor?: string
  Model?: string
  DNS?: DNS[]
  DNSSettings?: DNSSetting[]
  Addresses?: InterfaceAddress[]
  Routes?: InterfaceRoute[]
  NextHops?: NextHop[]
  DHCPv4Client?: DHCPv4Client
  DHCPv6Client?: DHCPv6Client
  DHCPServer?: DHCPServer
}

export interface RoutingPolicyRule {
  Family: AddressFamily
  Protocol: number
  ProtocolString: ProtocolString | string
  TOS: number
  Type: number
  TypeString: TypeString | string
  IPProtocol: number
  IPProtocolString: ProtocolString | string
  Priority: number
  FirewallMark: number
  FirewallMask: number
  Table?: number
  TableString: TableStringType
  Invert: boolean
  ConfigSource: ConfigSource
  ConfigState?: ConfigState
}

export interface NetworkStatus {
  Interfaces: NetworkInterface[]
  Routes: InterfaceRoute[]
  RoutingPolicyRules: RoutingPolicyRule[]
}

// DHCP Lease with interface context
export interface LeaseWithInterface extends DHCPLease {
  interfaceName: string
  isExpired: boolean
  timeRemaining: string
}