SecureProtocol {.pure.} = enum
  Noise

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: Opt[int]
  autonat: bool
  circuitRelay: Relay
  rdv: RendezVous
  services: seq[Service]
  observedAddrManager: ObservedAddrManager
  enableWildcardResolver: bool

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

MemoryAutoAddress = "/memory/*"

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

proc newStandardSwitch(privKey = none(PrivateKey); addrs: MultiAddress |
    seq[MultiAddress] = init(MultiAddress, "/ip4/127.0.0.1/tcp/0").expect(
    "valid address"); 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: [LPError], public, ...raises: [].}

proc withAddress(b: SwitchBuilder; address: MultiAddress;
                 enableWildcardResolver: bool = true): SwitchBuilder {.public,
    ...raises: [], tags: [].}

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

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

proc withAutonat(b: SwitchBuilder): SwitchBuilder {....raises: [], tags: [].}

proc withCircuitRelay(b: SwitchBuilder; r: Relay = Relay.new()): SwitchBuilder {.
    ...raises: [], tags: [].}

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

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

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

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

proc withMemoryTransport(b: SwitchBuilder): SwitchBuilder {.public, ...raises: [],
    tags: [RootEffect].}

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

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

proc withObservedAddrManager(b: SwitchBuilder;
                             observedAddrManager: ObservedAddrManager): SwitchBuilder {.
    ...raises: [], tags: [].}

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

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

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

proc withRendezVous(b: SwitchBuilder; rdv: RendezVous = RendezVous.new()): SwitchBuilder {.
    ...raises: [], tags: [].}

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

proc withServices(b: SwitchBuilder; services: seq[Service]): SwitchBuilder {.
    ...raises: [], tags: [].}

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

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

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