Direction {.pure.} = enum
  In, Out

InvalidVarintError = object of LPStreamError

LPStream = ref object of RootObj
  closeEvent*: AsyncEvent
  isClosed*: bool
  isEof*: bool
  objName*: string
  oid*: Oid
  dir*: Direction
  closedWithEOF: bool

LPStreamClosedError = object of LPStreamError

LPStreamEOFError = object of LPStreamError

LPStreamError = object of LPError

LPStreamIncompleteError = object of LPStreamError

LPStreamIncorrectDefect = object of Defect

LPStreamLimitError = object of LPStreamError

LPStreamReadError = object of LPStreamError
  par*: ref CatchableError

LPStreamWriteError = object of LPStreamError
  par*: ref CatchableError

MaxSizeError = object of LPStreamError

StreamTracker = ref object of TrackerBase
  opened*: uint64
  closed*: uint64

Eof = []

LPStreamTrackerName = "LPStream"

proc closeWithEOF(s: LPStream): Future[void] {.public(), stackTrace: false,
    ...gcsafe, raises: [Defect], raises: [Defect], tags: [RootEffect].}

proc join(s: LPStream): Future[void] {.public, ...raises: [Defect], tags: [].}

proc newLPStreamClosedError(): ref LPStreamClosedError {....raises: [Defect],
    tags: [].}

proc newLPStreamEOFError(): ref LPStreamEOFError {....raises: [Defect], tags: [].}

proc newLPStreamIncompleteError(): ref LPStreamIncompleteError {.
    ...raises: [Defect], tags: [].}

proc newLPStreamIncorrectDefect(m: string): ref LPStreamIncorrectDefect {.
    ...raises: [Defect], tags: [].}

proc newLPStreamLimitError(): ref LPStreamLimitError {....raises: [Defect],
    tags: [].}

proc newLPStreamReadError(msg: string): ref LPStreamReadError {.
    ...raises: [Defect], tags: [].}

proc newLPStreamReadError(p: ref CatchableError): ref LPStreamReadError {.
    ...raises: [Defect], tags: [].}

proc newLPStreamWriteError(p: ref CatchableError): ref LPStreamWriteError {.
    ...raises: [Defect], tags: [].}

proc readExactly(s: LPStream; pbytes: pointer; nbytes: int): Future[void] {.
    public(), stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

proc readLine(s: LPStream; limit = 0; sep = "\r\n"): Future[string] {.public(),
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

proc readLp(s: LPStream; maxSize: int): Future[seq[byte]] {....gcsafe, public(),
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

proc readVarint(conn: LPStream): Future[uint64] {....gcsafe, public(),
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

func shortLog(s: LPStream): auto {....raises: [Defect], tags: [].}

proc write(s: LPStream; msg: string): Future[void] {.public, ...raises: [Defect],
    tags: [].}

proc writeLp(s: LPStream; msg: openArray[byte]): Future[void] {.public,
    ...raises: [Defect], tags: [].}

proc writeLp(s: LPStream; msg: string): Future[void] {.public, ...raises: [Defect],
    tags: [].}

method atEof(s: LPStream): bool {.base, public, ...raises: [Defect], tags: [].}

method close(s: LPStream): Future[void] {.base, public(), stackTrace: false,
    ...gcsafe, raises: [Defect], raises: [Defect], tags: [RootEffect].}

method closed(s: LPStream): bool {.base, public, ...raises: [Defect], tags: [].}

method closeImpl(s: LPStream): Future[void] {.base, stackTrace: false, ...gcsafe,
    raises: [Defect], raises: [Defect], tags: [RootEffect].}

method initStream(s: LPStream) {.base, ...raises: [Defect], tags: [TimeEffect].}

method readOnce(s: LPStream; pbytes: pointer; nbytes: int): Future[int] {.base,
    public(), stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

method write(s: LPStream; msg: seq[byte]): Future[void] {.base, public,
    ...raises: [Defect], tags: [].}

template formatItIMPL(it: LPStream): auto