Refactoring 150k lines of code, part 1

export class CommandClass {
  public constructor(
    driver: Driver,
    options: CommandClassOptions
  ) {
    this.driver = driver;

    // other constructor logic
  }

  // other class logic
}

export class CommandClass {
  public constructor(
    host: ZWaveHost,
    options: CommandClassOptions
  ) {
    this.host = host;

    // other constructor logic
  }

  // other class logic
}

/** Host application abstractions to be used in Serial API and CC implementations */
export interface ZWaveHost {
  /** The ID of this node in the current network */
  ownNodeId: number;
  /** The Home ID of the current network */
  homeId: number;

  /** How many bytes a node ID occupies in serial API commands */
  readonly nodeIdType?: NodeIDType;

  /** Management of Security S0 keys and nonces */
  securityManager: SecurityManager | undefined;
  /** Management of Security S2 keys and nonces (Z-Wave Classic) */
  securityManager2: SecurityManager2 | undefined;
  /** Management of Security S2 keys and nonces (Z-Wave Long Range) */
  securityManagerLR: SecurityManager2 | undefined;

  /**
   * Retrieves the maximum version of a command class that can be used to communicate with a node.
   * Returns 1 if the node claims that it does not support a CC.
   * Throws if the CC is not implemented in this library yet.
   */
  getSafeCCVersion(
    cc: CommandClasses,
    nodeId: number,
    endpointIndex?: number,
  ): number;

  /**
   * Retrieves the maximum version of a command class the given node/endpoint has reported support for.
   * Returns 0 when the CC is not supported or that information is not known yet.
   */
  getSupportedCCVersion(
    cc: CommandClasses,
    nodeId: number,
    endpointIndex?: number,
  ): number;

  /**
   * Determines whether a CC must be secure for a given node and endpoint.
   */
  isCCSecure(
    cc: CommandClasses,
    nodeId: number,
    endpointIndex?: number,
  ): boolean;

  getHighestSecurityClass(nodeId: number): MaybeNotKnown<SecurityClass>;

  hasSecurityClass(
    nodeId: number,
    securityClass: SecurityClass,
  ): MaybeNotKnown<boolean>;

  setSecurityClass(
    nodeId: number,
    securityClass: SecurityClass,
    granted: boolean,
  ): void;

  /**
   * Returns the next callback ID. Callback IDs are used to correlate requests
   * to the controller/nodes with its response
   */
  getNextCallbackId(): number;

  /**
   * Returns the next session ID for supervised communication
   */
  getNextSupervisionSessionId(nodeId: number): number;

  getDeviceConfig?: (nodeId: number) => DeviceConfig | undefined;

  __internalIsMockNode?: boolean;
}

/** Host application abstractions that provide support for reading and writing values to a database */
export interface ZWaveValueHost {
  /** Returns the value DB which belongs to the node with the given ID, or throws if the Value DB cannot be accessed */
  getValueDB(nodeId: number): ValueDB;

  /** Returns the value DB which belongs to the node with the given ID, or `undefined` if the Value DB cannot be accessed */
  tryGetValueDB(nodeId: number): ValueDB | undefined;
}

/** A more featureful version of the ZWaveHost interface, which is meant to be used on the controller application side. */
export interface ZWaveApplicationHost extends ZWaveValueHost, ZWaveHost {
  /** Gives access to the configuration files */
  configManager: ConfigManager;

  options: ZWaveHostOptions;

  // TODO: There's probably a better fitting name for this now
  controllerLog: ControllerLogger;

  /** Readonly access to all node instances known to the host */
  nodes: ReadonlyThrowingMap<number, IZWaveNode>;

  /** Whether the node with the given ID is the controller */
  isControllerNode(nodeId: number): boolean;

  sendCommand<TResponse extends ICommandClass | undefined = undefined>(
    command: ICommandClass,
    options?: SendCommandOptions,
  ): Promise<SendCommandReturnType<TResponse>>;

  waitForCommand<T extends ICommandClass>(
    predicate: (cc: ICommandClass) => boolean,
    timeout: number,
  ): Promise<T>;

  schedulePoll(
    nodeId: number,
    valueId: ValueID,
    options: NodeSchedulePollOptions,
  ): boolean;
}

/** Allows querying the home ID and node ID of the host */
export interface HostIDs {
  /** The ID of this node in the current network */
  ownNodeId: number;
  /** The Home ID of the current network */
  homeId: number;
}

/** Allows looking up Z-Wave manufacturers by manufacturer ID */
export interface LookupManufacturer {
  /** Looks up the name of the manufacturer with the given ID in the configuration DB */
  lookupManufacturer(manufacturerId: number): string | undefined;
}

/** Allows accessing a specific node */
export interface GetNode<T extends NodeId> {
  getNode(nodeId: number): T | undefined;
  getNodeOrThrow(nodeId: number): T;
}

/** Identifies a node */
export interface NodeId extends EndpointId {
  readonly id: number;
}

/** Identifies an endpoint */
export interface EndpointId {
  readonly virtual: false;
  readonly nodeId: number;
  readonly index: number;
}

function getEndpointInformation(
  context: GetNode<
    & NodeId
    & GetEndpoint<
      & EndpointId
      & SupportsCC
      & ControlsCC
    >
  >
) { ... }

// Defines the necessary traits the host passed to a CC API must have
export type CCAPIHost<TNode extends CCAPINode = CCAPINode> =
  & HostIDs
  & GetNode<TNode>
  & GetValueDB
  & GetSupportedCCVersion
  & GetSafeCCVersion
  & SecurityManagers
  & GetDeviceConfig
  & SendCommand
  & GetCommunicationTimeouts
  & GetUserPreferences
  & SchedulePoll
  & LogNode;

// Defines the necessary traits an endpoint passed to a CC API must have
export type CCAPIEndpoint =
  & (
    | (
      // Physical endpoints must let us query their controlled CCs
      EndpointId & ControlsCC
    )
    | (
      // Virtual endpoints must let us query their physical nodes,
      // the CCs those nodes implement, and access the endpoints of those
      // physical nodes
      VirtualEndpointId & {
        node: PhysicalNodes<
          & NodeId
          & SupportsCC
          & ControlsCC
          & GetEndpoint<EndpointId & SupportsCC & ControlsCC>
        >;
      }
    )
  )
  & SupportsCC;