SecureProtocol {.pure.} = enum
  Noise, Secio {....deprecated.}

SwitchBuilder = ref object
  privKey: Option[PrivateKey]
  addresses: seq[MultiAddress]
  secureManagers: seq[SecureProtocol]
  muxers: seq[MuxerProvider]
  transports: seq[TransportProvider]
  rng: ref HmacDrbgContext
  maxConnections: int
  maxIn: int
  sendSignedPeerRecord: bool
  maxOut: int
  maxConnsPerPeer: int
  protoVersion: string
  agentVersion: string
  nameResolver: NameResolver
  peerStoreCapacity: Option[int]
  isCircuitRelay: bool
  circuitRelayCanHop: bool

TransportProvider {.public.} = proc (upgr: Upgrade): Transport {....gcsafe,
    raises: [Defect].}

proc new(T: type[SwitchBuilder]): T:type {.public, ...raises: [Defect].}

proc newStandardSwitch(privKey = none(PrivateKey); addrs: MultiAddress |
    seq[MultiAddress] = init(MultiAddress, "/ip4/127.0.0.1/tcp/0").tryGet();
    secureManagers: openArray[SecureProtocol] = [SecureProtocol.Noise];
                       transportFlags: set[ServerFlags] = {}; rng = newRng();
                       inTimeout: Duration = 5.minutes;
                       outTimeout: Duration = 5.minutes;
                       maxConnections = MaxConnections; maxIn = -1; maxOut = -1;
                       maxConnsPerPeer = MaxConnectionsPerPeer;
                       nameResolver: NameResolver = nil;
                       sendSignedPeerRecord = false; peerStoreCapacity = 1000): Switch {.
    ...raises: [Defect, LPError], public, ...raises: [Defect].}

proc withAddress(b: SwitchBuilder; address: MultiAddress): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withAddresses(b: SwitchBuilder; addresses: seq[MultiAddress]): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withAgentVersion(b: SwitchBuilder; agentVersion: string): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withMaxConnections(b: SwitchBuilder; maxConnections: int): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withMaxConnsPerPeer(b: SwitchBuilder; maxConnsPerPeer: int): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withMaxIn(b: SwitchBuilder; maxIn: int): SwitchBuilder {.public,
    ...raises: [Defect], tags: [].}

proc withMaxOut(b: SwitchBuilder; maxOut: int): SwitchBuilder {.public,
    ...raises: [Defect], tags: [].}

proc withNameResolver(b: SwitchBuilder; nameResolver: NameResolver): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withNoise(b: SwitchBuilder): SwitchBuilder {.public, ...raises: [Defect],
    tags: [].}

proc withPeerStore(b: SwitchBuilder; capacity: int): SwitchBuilder {.public,
    ...raises: [Defect], tags: [].}

proc withPrivateKey(b: SwitchBuilder; privateKey: PrivateKey): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withProtoVersion(b: SwitchBuilder; protoVersion: string): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withRelayTransport(b: SwitchBuilder; canHop: bool): SwitchBuilder {.
    ...raises: [Defect], tags: [].}

proc withRng(b: SwitchBuilder; rng: ref HmacDrbgContext): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withSignedPeerRecord(b: SwitchBuilder; sendIt = true): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}

proc withTcpTransport(b: SwitchBuilder; flags: set[ServerFlags] = {}): SwitchBuilder {.
    public, ...raises: [Defect], tags: [RootEffect].}

proc withTransport(b: SwitchBuilder; prov: TransportProvider): SwitchBuilder {.
    public, ...raises: [Defect], tags: [].}