AdvertiseError = object of DiscoveryError

DiscoveryError = object of LPError

DiscoveryFinished = object of LPError

DiscoveryInterface = ref object of RootObj
  onPeerFound*: PeerFoundCallback
  toAdvertise*: PeerAttributes
  advertisementUpdated*: AsyncEvent
  advertiseLoop*: Future[void]

DiscoveryManager = ref object
  interfaces: seq[DiscoveryInterface]
  queries: seq[DiscoveryQuery]

DiscoveryQuery = ref object
  attr: PeerAttributes
  peers: AsyncQueue[PeerAttributes]
  finished: bool
  futs: seq[Future[void]]

DiscoveryService = distinct string

PeerAttributes = object
  attributes: seq[BaseAttr]

PeerFoundCallback = proc (pa: PeerAttributes) {....raises: [], gcsafe.}

proc `==`(a, b: DiscoveryService): bool {.borrow, ...raises: [], tags: [].}

proc `[]`[T](pa: PeerAttributes; t: typedesc[T]): T {....raises: [KeyError],
    raises: [].}

proc `{}`[T](pa: PeerAttributes; t: typedesc[T]): Opt[T] {....raises: [].}

proc add(dm: DiscoveryManager; di: DiscoveryInterface) {....raises: [], tags: [].}

proc add[T](pa: var PeerAttributes; value: T) {....raises: [].}

proc advertise[T](dm: DiscoveryManager; value: T) {....raises: [].}

proc getAll[T](pa: PeerAttributes; t: typedesc[T]): seq[T] {....raises: [].}

proc getPeer(query: DiscoveryQuery): InternalRaisesFuture[PeerAttributes,
    (CancelledError, DiscoveryError, DiscoveryFinished)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

proc match(pa, candidate: PeerAttributes): bool {....raises: [], tags: [RootEffect].}

proc ofType[T](f: BaseAttr; _: type[T]): bool {....raises: [].}

proc request(dm: DiscoveryManager; pa: PeerAttributes): DiscoveryQuery {.
    ...raises: [], tags: [RootEffect].}

proc request[T](dm: DiscoveryManager; value: T): DiscoveryQuery {....raises: [].}

proc stop(dm: DiscoveryManager) {....raises: [], tags: [RootEffect].}

proc stop(query: DiscoveryQuery) {....raises: [], tags: [RootEffect].}

proc to[T](f: BaseAttr; _: type[T]): T {....raises: [].}

method advertise(self: DiscoveryInterface): InternalRaisesFuture[void,
    (CancelledError, AdvertiseError)] {.base, stackTrace: false, ...raises: [],
                                        gcsafe, raises: [], raises: [],
                                        tags: [RootEffect].}

method request(self: DiscoveryInterface; pa: PeerAttributes): InternalRaisesFuture[
    void, (DiscoveryError, CancelledError)] {.base, stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

iterator items(pa: PeerAttributes): BaseAttr {....raises: [], tags: [].}

template forEach(query: DiscoveryQuery; code: untyped)