chronos/apps/http/httpserver

Search:
Group by:
Source   Edit  

Types

ByteChar = string | seq[byte]
Source   Edit   
ConnectionFence = Result[HttpConnectionRef, HttpProcessError]
Result type that can contain either a valid HttpConnectionRef or an HttpProcessError. Source   Edit   
HttpCloseConnectionCallback = proc (connection: HttpConnectionRef): Future[void] {.
    async: (...raises: []).}
Source   Edit   
HttpConnection = object of RootObj
  state*: HttpState
  server*: HttpServerRef
  transp*: StreamTransport
  mainReader*: AsyncStreamReader
  mainWriter*: AsyncStreamWriter
  reader*: AsyncStreamReader
  writer*: AsyncStreamWriter
  closeCb*: HttpCloseConnectionCallback
  createMoment*: Moment
  currentRawQuery*: Opt[string]
Source   Edit   
HttpConnectionCallback = proc (server: HttpServerRef; transp: StreamTransport): Future[
    HttpConnectionRef] {.async: (...raises: [CancelledError, HttpConnectionError]).}
Source   Edit   
HttpConnectionHolder = object of RootObj
  connection*: HttpConnectionRef
  server*: HttpServerRef
  future*: Future[void]
  transp*: StreamTransport
  acceptMoment*: Moment
  connectionId*: string
Source   Edit   
HttpProcessCallback = proc (req: RequestFence): Future[HttpResponseRef] {.
    ...gcsafe, raises: [].}
Source   Edit   
HttpProcessCallback2 = proc (req: RequestFence): Future[HttpResponseRef] {.
    async: (...raises: [CancelledError]).}
Source   Edit   
HttpProcessError = object
  kind*: HttpServerError
  code*: HttpCode
  exc*: ref HttpError
  remote*: Opt[TransportAddress]
Source   Edit   
HttpProcessExitType {.pure.} = enum
  KeepAlive, Graceful, Immediate
Source   Edit   
HttpRequest = object of RootObj
  state*: HttpState
  headers*: HttpTable
  query*: HttpTable
  rawPath*: string
  uri*: Uri
  scheme*: string
  version*: HttpVersion
  meth*: HttpMethod
  contentEncoding* {....deprecated.}: set[ContentEncodingFlags]
  transferEncoding* {....deprecated.}: set[TransferEncodingFlags]
  contentEncodings*: seq[ContentEncodingFlags]
  transferEncodings*: seq[TransferEncodingFlags]
  requestFlags*: set[HttpRequestFlags]
  contentLength*: int
  contentTypeData*: Opt[ContentTypeData]
  connection*: HttpConnectionRef
  response*: Opt[HttpResponseRef]
Source   Edit   
HttpRequestFlags {.pure.} = enum
  BoundBody, UnboundBody, MultipartForm, UrlencodedForm, ClientExpect
Source   Edit   
HttpResponse = object of RootObj
  status*: HttpCode
  version*: HttpVersion
  state*: HttpResponseState
  connection*: HttpConnectionRef
  streamType*: HttpResponseStreamType
Source   Edit   
HttpResponseFlags {.pure.} = enum
  KeepAlive, Stream
Source   Edit   
HttpResponseState {.pure.} = enum
  Empty, Prepared, Sending, Finished, Failed, Cancelled, ErrorCode, Default
Source   Edit   
HttpResponseStreamType {.pure.} = enum
  Plain, SSE, Chunked
Source   Edit   
HttpServer = object of RootObj
  instance*: StreamServer
  address*: TransportAddress
  maxConnections*: int
  backlogSize*: int
  baseUri*: Uri
  serverIdent*: string
  flags*: set[HttpServerFlags]
  socketFlags*: set[ServerFlags]
  connections*: OrderedTable[string, HttpConnectionHolderRef]
  acceptLoop*: Future[void].Raising([])
  lifetime*: Future[void]
  headersTimeout*: Duration
  bufferSize*: int
  maxHeadersSize*: int
  maxRequestBodySize*: int
  processCallback*: HttpProcessCallback2
  createConnCallback*: HttpConnectionCallback
Source   Edit   
HttpServerError {.pure.} = enum
  InterruptError, TimeoutError, ProtocolError, DisconnectError
Source   Edit   
HttpServerFlags {.pure.} = enum
  Secure,                   ## Internal flag which indicates that server working in secure TLS mode
  NoExpectHandler,          ## Do not handle `Expect` header automatically
  NotifyDisconnect,         ## Notify user-callback when remote client disconnects.
  QueryCommaSeparatedArray, ## Enable usage of comma as an array item delimiter in url-encoded
                             ## entities (e.g. query string or POST body).
  Http11Pipeline ## Enable persistent connections in HTTP/1.1 - the name refers to
                 ## pipelining for historical reasons.
Source   Edit   
HttpServerMiddleware = object of RootObj
  handler*: MiddlewareHandleCallback
Source   Edit   
HttpServerState {.pure.} = enum
  ServerRunning, ServerStopped, ServerClosed
Source   Edit   
MiddlewareHandleCallback = proc (middleware: HttpServerMiddlewareRef;
                                 request: RequestFence;
                                 handler: HttpProcessCallback2): Future[
    HttpResponseRef] {.async: (...raises: [CancelledError]).}
Source   Edit   
RequestFence = Result[HttpRequestRef, HttpProcessError]
Result type that can contain either a valid HttpRequestRef or an HttpProcessError. Source   Edit  

Procs

proc addHeader(resp: HttpResponseRef; key, value: string) {....raises: [],
    tags: [], forbids: [].}
Adds value value to header's key value. Source   Edit   
proc closeWait(conn: HttpConnectionRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Source   Edit   
proc closeWait(req: HttpRequestRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Source   Edit   
proc closeWait(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Stop HTTP server and drop all the pending connections. Source   Edit   
proc codeResponse(status: HttpCode): HttpResponseRef {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc consumeBody(request: HttpRequestRef): InternalRaisesFuture[void,
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Consume/discard request's body. Source   Edit   
proc defaultResponse(): HttpResponseRef {....raises: [], tags: [], forbids: [].}
Create an empty response to return when request processor got no request. Source   Edit   
proc defaultResponse(err: HttpProcessError): HttpResponseRef {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc defaultResponse(exc: ref CatchableError): HttpResponseRef {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc defaultResponse(msg: HttpMessage): HttpResponseRef {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc drop(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Drop all pending HTTP connections. Source   Edit   
proc dropResponse(): HttpResponseRef {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc dumbResponse(): HttpResponseRef {....deprecated: "Please use defaultResponse() instead",
                                       raises: [], tags: [], forbids: [].}
Deprecated: Please use defaultResponse() instead
Create an empty response to return when request processor got no request. Source   Edit   
proc error(e: HttpProcessError): HttpServerError {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc finish(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Sending last chunk of data, so it will indicate end of HTTP response. Source   Edit   
proc getAcceptInfo(request: HttpRequestRef): Result[AcceptInfo, cstring] {.
    ...raises: [], tags: [], forbids: [].}

Returns value of Accept header as AcceptInfo object.

If Accept header is missing in request headers, */* content type will be returned.

Source   Edit   
proc getBody(request: HttpRequestRef): InternalRaisesFuture[seq[byte],
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Obtain request's body as sequence of bytes. Source   Edit   
proc getBodyReader(request: HttpRequestRef): HttpResult[HttpBodyReader] {.
    ...raises: [], tags: [], forbids: [].}

Returns stream's reader instance which can be used to read request's body.

Please be sure to handle Expect header properly.

Streams which was obtained using this procedure must be closed to avoid leaks.

Source   Edit   
proc getConnectionFence(server: HttpServerRef; transp: StreamTransport): InternalRaisesFuture[
    ConnectionFence, void] {....stackTrace: false, raises: [], gcsafe, raises: [],
                             tags: [RootEffect], forbids: [].}
Source   Edit   
proc getHeader(resp: HttpResponseRef; key: string; default: string = ""): string {.
    ...raises: [], tags: [], forbids: [].}
Returns value of header with name name or default, if header is not present in the table. Source   Edit   
proc getHostname(server: HttpServerRef): string {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc getMultipartReader(req: HttpRequestRef): HttpResult[MultiPartReaderRef] {.
    ...raises: [], tags: [], forbids: [].}
Create new MultiPartReader interface for specific request. Source   Edit   
proc getRequestFence(server: HttpServerRef; connection: HttpConnectionRef): InternalRaisesFuture[
    RequestFence, void] {....stackTrace: false, raises: [], gcsafe, raises: [],
                          tags: [RootEffect], forbids: [].}
Source   Edit   
proc getResponse(req: HttpRequestRef): HttpResponseRef {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc getResponseState(response: HttpResponseRef): HttpResponseState {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc gracefulCloseWait(conn: HttpConnectionRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Source   Edit   
proc handleExpect(request: HttpRequestRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Handle expectation for Expect header. https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expect Source   Edit   
proc hasBody(request: HttpRequestRef): bool {....raises: [], tags: [], forbids: [].}
Returns true if request has body. Source   Edit   
proc hasHeader(resp: HttpResponseRef; key: string): bool {....raises: [], tags: [],
    forbids: [].}
Returns true if header with name key present in the headers table. Source   Edit   
proc init(value: var HttpConnection; server: HttpServerRef;
          transp: StreamTransport) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc join(server: HttpServerRef): InternalRaisesFuture[void, (CancelledError,)] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [], forbids: [].}
Source   Edit   
proc keepalive(resp: HttpResponseRef): bool {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc keepalive=(resp: HttpResponseRef; value: bool) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc local(request: HttpRequestRef): Opt[TransportAddress] {....raises: [],
    tags: [], forbids: [].}
Returns local address of HTTP request's connection. Source   Edit   
proc new(htype: typedesc[HttpServerRef]; address: TransportAddress;
         processCallback: HttpProcessCallback2;
         serverFlags: set[HttpServerFlags] = {};
         socketFlags: set[ServerFlags] = {ReuseAddr}; serverUri = Uri();
         serverIdent = ""; maxConnections: int = -1;
         bufferSize: int = chronosTransportDefaultBufferSize;
         backlogSize: int = DefaultBacklogSize; httpHeadersTimeout = 10.seconds;
         maxHeadersSize: int = 8192; maxRequestBodySize: int = 1048576;
         dualstack = DualStackType.Auto;
         middlewares: openArray[HttpServerMiddlewareRef] = []): HttpResult[
    HttpServerRef] {....raises: [].}
Source   Edit   
proc new(htype: typedesc[HttpServerRef]; address: TransportAddress;
         processCallback: HttpProcessCallback;
         serverFlags: set[HttpServerFlags] = {};
         socketFlags: set[ServerFlags] = {ReuseAddr}; serverUri = Uri();
         serverIdent = ""; maxConnections: int = -1;
         bufferSize: int = chronosTransportDefaultBufferSize;
         backlogSize: int = DefaultBacklogSize; httpHeadersTimeout = 10.seconds;
         maxHeadersSize: int = 8192; maxRequestBodySize: int = 1048576;
         dualstack = DualStackType.Auto;
         middlewares: openArray[HttpServerMiddlewareRef] = []): HttpResult[
    HttpServerRef] {....deprecated: "Callback could raise only CancelledError, annotate with {.async: (raises: [CancelledError]).}",
                     raises: [].}
Deprecated: Callback could raise only CancelledError, annotate with {.async: (raises: [CancelledError]).}
Source   Edit   
proc post(req: HttpRequestRef): InternalRaisesFuture[HttpTable,
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Return POST parameters Source   Edit   
proc preferredContentMediaType(acceptHeader: string): MediaType {....raises: [],
    tags: [], forbids: [].}
Returns preferred content-type using Accept header value specified by string acceptHeader. Source   Edit   
proc preferredContentMediaType(request: HttpRequestRef): MediaType {....raises: [],
    tags: [], forbids: [].}
Returns preferred content-type using Accept header specified by client in request request. Source   Edit   
proc preferredContentType(acceptHeader: string; types: varargs[MediaType]): Result[
    MediaType, cstring] {....raises: [], tags: [], forbids: [].}

Match or obtain preferred content type using Accept header specified by string acceptHeader and server preferred content types types.

If Accept header is missing in client's request - types[0] or */* value will be returned as result.

If Accept header has incorrect format in client's request - types[0] or */* value will be returned as result.

If Accept header is present in request to server and it has one or more content types supported by client, the best value will be selected from types using position and quality value (weight) reported in Accept header. If client do not support any methods in types error will be returned.

Note: Quality value (weight) for content type has priority over server's preferred content-type.

Source   Edit   
proc preferredContentType(request: HttpRequestRef; types: varargs[MediaType]): Result[
    MediaType, cstring] {....raises: [], tags: [], forbids: [].}
Match or obtain preferred content-type using Accept header specified by client in request request. Source   Edit   
proc prepare(resp: HttpResponseRef; streamType = HttpResponseStreamType.Chunked): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}

Prepare for HTTP stream response.

Such responses will be sent chunk by chunk using chunked encoding.

Source   Edit   
proc prepareChunked(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Source   Edit   
proc preparePlain(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Source   Edit   
proc prepareSSE(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Source   Edit   
proc redirect(req: HttpRequestRef; code: HttpCode; location: string): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {....stackTrace: false,
    raises: [], gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Source   Edit   
proc redirect(req: HttpRequestRef; code: HttpCode; location: string;
              headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Source   Edit   
proc redirect(req: HttpRequestRef; code: HttpCode; location: Uri): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {....stackTrace: false,
    raises: [], gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Source   Edit   
proc redirect(req: HttpRequestRef; code: HttpCode; location: Uri;
              headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [], tags: [RootEffect],
                                        forbids: [].}
Source   Edit   
proc remote(request: HttpRequestRef): Opt[TransportAddress] {....raises: [],
    tags: [], forbids: [].}
Returns remote address of HTTP request's connection. Source   Edit   
proc remoteAddress(conn: HttpConnectionRef): TransportAddress {.
    ...raises: [HttpAddressError], raises: [], tags: [], forbids: [].}
Returns address of the remote host that established connection conn. Source   Edit   
proc remoteAddress(request: HttpRequestRef): TransportAddress {.
    ...raises: [HttpAddressError], raises: [], tags: [], forbids: [].}
Returns address of the remote host that made request request. Source   Edit   
proc requestInfo(req: HttpRequestRef; contentType = "text/plain"): string {.
    ...raises: [], tags: [], forbids: [].}

Returns comprehensive information about request for specific content type.

Only two content-types are supported: "text/text" and "text/html".

Source   Edit   
proc respond(req: HttpRequestRef; code: HttpCode): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {....stackTrace: false,
    raises: [], gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Source   Edit   
proc respond(req: HttpRequestRef; code: HttpCode; content: ByteChar): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {....stackTrace: false,
    raises: [], gcsafe, raises: [].}
Source   Edit   
proc respond(req: HttpRequestRef; code: HttpCode; content: ByteChar;
             headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [].}
Responds to the request with the specified HttpCode, HTTP headers and content. Source   Edit   
proc responded(req: HttpRequestRef): bool {....raises: [], tags: [], forbids: [].}
Returns true if request req has been responded or responding. Source   Edit   
proc send(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [].}
Send single chunk of data data. Source   Edit   
proc send(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Send single chunk of data pointed by pbytes and nbytes. Source   Edit   
proc sendBody(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [], gcsafe,
                                        raises: [].}
Send HTTP response at once by using data data. Source   Edit   
proc sendBody(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Send HTTP response at once by using bytes pointer pbytes and length nbytes. Source   Edit   
proc sendChunk(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [].}
Source   Edit   
proc sendChunk(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Source   Edit   
proc sendError(resp: HttpResponseRef; code: HttpCode; body = ""): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Send HTTP error status response. Source   Edit   
proc sendEvent(resp: HttpResponseRef; eventName: string; data: string): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {....stackTrace: false, raises: [],
    gcsafe, raises: [], tags: [RootEffect], forbids: [].}
Source   Edit   
proc setHeader(resp: HttpResponseRef; key, value: string) {....raises: [],
    tags: [], forbids: [].}
Sets value of header key to value. Source   Edit   
proc setHeaderDefault(resp: HttpResponseRef; key, value: string) {....raises: [],
    tags: [], forbids: [].}
Sets value of header key to value, only if header key is not present in the headers table. Source   Edit   
proc start(server: HttpServerRef) {....raises: [], tags: [RootEffect], forbids: [].}
Starts HTTP server. Source   Edit   
proc state(server: HttpServerRef): HttpServerState {....raises: [], tags: [],
    forbids: [].}
Returns current HTTP server's state. Source   Edit   
proc stop(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    ...stackTrace: false, raises: [], gcsafe, raises: [], tags: [RootEffect],
    forbids: [].}
Stop HTTP server from accepting new connections. Source   Edit   
proc updateRequest(request: HttpRequestRef; headers: HttpTable): HttpResultMessage[
    void] {....raises: [], tags: [], forbids: [].}
Update HTTP request object using base request object with new properties. Source   Edit   
proc updateRequest(request: HttpRequestRef; meth: HttpMethod;
                   requestUri: string; headers: HttpTable): HttpResultMessage[
    void] {....raises: [], tags: [], forbids: [].}
Update HTTP request object using base request object with new properties. Source   Edit   
proc updateRequest(request: HttpRequestRef; requestUri: string): HttpResultMessage[
    void] {....raises: [], tags: [], forbids: [].}
Update HTTP request object using base request object with new properties. Source   Edit   
proc updateRequest(request: HttpRequestRef; requestUri: string;
                   headers: HttpTable): HttpResultMessage[void] {....raises: [],
    tags: [], forbids: [].}
Update HTTP request object using base request object with new properties. Source   Edit   
proc updateRequest(request: HttpRequestRef; scheme: string; meth: HttpMethod;
                   version: HttpVersion; requestUri: string; headers: HttpTable): HttpResultMessage[
    void] {....raises: [], tags: [], forbids: [].}
Update HTTP request object using base request object with new properties. Source   Edit  

Exports

NestedPoll, closeSocket, ENOSR, EHOSTUNREACH, EHOSTDOWN, ECONNRESET, EDQUOT, fail, ECANCELED, EMLINK, milliseconds, asyncTimer, +=, $, Second, internalRaiseIfError, getSrcLocation, FutureError, fromNow, weeks, ESPIPE, withTimeout, LocationKind, id, <=, FutureBase, FutureCompletedError, ENOEXEC, ESHUTDOWN, fail, EREMOTEIO, Day, waitFor, complete, internalInitFutureBase, EPROTONOSUPPORT, cancelAndWait, addTimer, Moment, ECOMM, EPROTOTYPE, AsyncExceptionError, FuturePendingError, milliseconds, ENOENT, millis, removeTimer, or, FutureFlag, ENOTCONN, EBUSY, init, ENOTUNIQ, <=, days, +=, race, ==, cancelSoon, AsyncTimeoutError, setThreadDispatcher, EEXIST, ENOLINK, newInternalRaisesFuture, idleAsync, internalRaiseIfError, SomeIntegerI64, ENOMEM, ENOKEY, +, removeWriter2, ENOMSG, EKEYEXPIRED, Week, cancelSoon, awaitne, EAFNOSUPPORT, EWOULDBLOCK, [], EREMOTE, finished, AsyncCallback, EHWPOISON, epochSeconds, newDispatcher, EPERM, microseconds, internalFail, weeks, Finished, ENOTSOCK, cancelCallback=, ETOOMANYREFS, $, EISCONN, callSoon, ESOCKTNOSUPPORT, setGlobalDispatcher, EXDEV, EBADF, EKEYREVOKED, allFinished, TrackerBase, hours, InternalAsyncCallback, EBFONT, ENETDOWN, EACCES, ELOOP, InfiniteDuration, ETIMEDOUT, EINVAL, value, EBADFD, Future, completed, PDispatcher, ESRCH, EL2NSYNC, Finished, low, await, ESTRPIPE, -=, EALREADY, getAsyncTimestamp, EXFULL, Hour, EIDRM, removeReader2, secs, getThreadDispatcher, futureContinue, isZero, ENOANO, EADV, CallbackFunc, contains, cancelAndWait, $, ENFILE, waitFor, high, Microsecond, ENOPKG, ELIBBAD, EOWNERDEAD, handle, ERANGE, done, ENONET, completed, callSoon, toString, cancelSoon, EMSGSIZE, EBADMSG, EILSEQ, ENOPROTOOPT, EDESTADDRREQ, allFutures, -, complete, FutureState, EBADR, nanos, location, FutureDefect, EDOTDOT, one, EKEYREJECTED, <, race, error, one, CancelledError, nanoseconds, EISDIR, sleepAsync, Nanosecond, EOVERFLOW, FutureSeq, cancelAndWait, micros, -, ESRMNT, ENOTEMPTY, EPROTO, TimerCallback, microseconds, error, epochNanoSeconds, ENOTRECOVERABLE, wait, EDOM, value, hours, AsyncError, EBADRQC, ENODEV, FutureStr, addTimer, ENOBUFS, ECHRNG, ENOTDIR, EUNATCH, cancelAndSchedule, failed, nanoseconds, ERESTART, *, ETXTBSY, newFutureStr, EMFILE, LocFinishIndex, withTimeout, addTimer, race, EUSERS, ENOTBLK, Minute, DispatcherHandle, EISNAM, ELIBACC, ENAVAIL, init, race, EUCLEAN, ENOTTY, +, cancelSoon, completed, minutes, cancel, FutureFlags, getGlobalDispatcher, ELIBEXEC, stepsAsync, micros, wait, cancelAndWait, EINPROGRESS, EPFNOSUPPORT, E2BIG, -=, ENOMEDIUM, secs, read, waitFor, EL3HLT, unregisterAndCloseFd, EBADSLT, InternalRaisesFuture, -, <, ENETRESET, fastEpochTime, ENXIO, join, EPIPE, ThreadCallbackFunc, allFutures, race, wait, now, read, asyncSpawn, removeCallback, EAGAIN, raiseOsDefect, EADDRNOTAVAIL, read, removeCallback, TrackerCounter, async, addCallback, init, async, ZeroDuration, EREMCHG, EFAULT, addCallback, seconds, noCancel, low, AsyncFD, ECHILD, Raising, init, ECONNABORTED, state, wait, removeTimer, LocCreateIndex, addReader2, ETIME, ENOLCK, EBADE, EDEADLK, asyncCheck, Duration, ELNRNG, ENOCSI, millis, EMEDIUMTYPE, readError, sleepAsync, isInfinite, callback=, ENETUNREACH, InternalFutureBase, ENOSPC, ENOSYS, ELIBSCN, EIO, EROFS, seconds, ELIBMAX, SrcLoc, ==, ==, div, init, EL2HLT, EOPNOTSUPP, tryCancel, poll, flags, clearTimer, register2, LocCompleteIndex, days, ENOSTR, EADDRINUSE, one, ENAMETOOLONG, EMULTIHOP, ESTALE, await, ENODATA, EFBIG, +, minutes, ERFKILL, cancelled, toException, or, EDEADLOCK, allFutures, MaxEventsCount, wait, read, raiseAsDefect, Millisecond, setTimer, unregister2, failed, waitFor, newFutureSeq, callback=, orImpl, ECONNREFUSED, high, ENOTNAM, nanos, addWriter2, removeTimer, EINTR, join, closeHandle, EL3RST, readError, *, newFuture, []=, EDQUOT, internalRaiseIfError, closeSocket, EHOSTUNREACH, EHOSTDOWN, closeWait, ECONNRESET, fail, ECANCELED, EMLINK, milliseconds, InternalRaisesFuture, CallbackFunc, +=, $, Second, NestedPoll, getSrcLocation, FutureError, fromNow, close, weeks, ESPIPE, withTimeout, LocationKind, id, isSet, <=, FutureCompletedError, ENOEXEC, SomeIntegerI64, fail, EREMOTEIO, or, ENOTTY, waitFor, addTimer, internalInitFutureBase, EPROTONOSUPPORT, nanoseconds, ==, cancelAndWait, contains, ENOPKG, Moment, ECOMM, addFirst, register, EPROTOTYPE, AsyncExceptionError, AsyncSemaphore, ENOCSI, milliseconds, ENOENT, millis, [], removeTimer, ENOSR, ==, EADDRNOTAVAIL, ENOTCONN, EBUSY, init, waitFor, asyncTimer, days, +=, race, EAFNOSUPPORT, ZeroDuration, cancelSoon, AsyncTimeoutError, []=, setThreadDispatcher, EEXIST, isInfinite, ENOLINK, newInternalRaisesFuture, idleAsync, internalRaiseIfError, ESHUTDOWN, ENOMEM, ==, ENOKEY, +, removeWriter2, ENOMSG, EKEYEXPIRED, Week, cancelSoon, awaitne, EWOULDBLOCK, EREMOTE, unregister, EPERM, tryAcquire, finished, AsyncCallback, EHWPOISON, epochSeconds, newDispatcher, microseconds, AsyncEvent, internalFail, sleepAsync, addCallback, weeks, Finished, cancelCallback=, ETOOMANYREFS, mitems, EISCONN, callSoon, ESOCKTNOSUPPORT, newAsyncQueue, setGlobalDispatcher, AsyncQueue, release, EXDEV, EBADF, cancelSoon, allFinished, microseconds, hours, wait, ENETDOWN, EACCES, AsyncEventQueue, ELOOP, InfiniteDuration, ETIMEDOUT, clear, EINVAL, value, EBADFD, Future, addCallback, len, completed, PDispatcher, ESRCH, EL2NSYNC, Finished, low, await, ESTRPIPE, -=, ENOLCK, [], getAsyncTimestamp, div, Hour, EIDRM, removeReader2, EventQueueReader, secs, getThreadDispatcher, EventQueueKey, futureContinue, popFirstNoWait, isZero, ENOANO, readError, <=, cancelAndWait, $, tryCancel, addLastNoWait, FutureBase, waitFor, high, Microsecond, complete, $, pairs, ELIBBAD, EOWNERDEAD, handle, ERANGE, done, clearTimer, popLastNoWait, contains, or, ENONET, completed, callSoon, cancelSoon, EMSGSIZE, EALREADY, EBADMSG, EILSEQ, ENOPROTOOPT, race, allFutures, empty, -, addTimer, FutureState, addFirstNoWait, EBADR, nanos, location, FutureDefect, EDOTDOT, ENOBUFS, put, EKEYREJECTED, <, Minute, error, one, CancelledError, EISDIR, release, EKEYREVOKED, FutureSeq, cancelAndWait, micros, -, ESRMNT, ENOTEMPTY, EPROTO, TimerCallback, TrackerBase, ENOTRECOVERABLE, EBFONT, cancelAndWait, hours, AsyncError, EBADRQC, ENODEV, ENFILE, complete, callback=, one, ECHRNG, wait, EUNATCH, cancelAndSchedule, acquire, failed, nanoseconds, ERESTART, *, ETXTBSY, availableSlots, newFutureStr, full, getNoWait, EMFILE, LocFinishIndex, orImpl, withTimeout, addTimer, race, EUSERS, ENOTBLK, race, DispatcherHandle, EISNAM, ELIBACC, init, EXFULL, EUCLEAN, race, +, EOVERFLOW, minutes, cancel, FutureFlags, getGlobalDispatcher, popFirst, ELIBEXEC, stepsAsync, error, micros, wait, clear, EINPROGRESS, completed, E2BIG, -=, ENOMEDIUM, secs, AsyncQueueEmptyError, value, read, waitFor, EINTR, newAsyncSemaphore, unregisterAndCloseFd, EBADSLT, [], -, <, ENETRESET, fastEpochTime, waitEvents, seconds, EDOM, FuturePendingError, EPIPE, AsyncLockError, InternalFutureBase, ThreadCallbackFunc, allFutures, len, EDESTADDRREQ, ENAVAIL, await, EPFNOSUPPORT, wait, EMULTIHOP, read, asyncSpawn, removeCallback, EAGAIN, raiseOsDefect, FutureFlag, read, removeCallback, TrackerCounter, async, AsyncLock, init, popLast, async, ENOSPC, EREMCHG, EFAULT, fire, ENXIO, seconds, noCancel, low, AsyncFD, ECHILD, init, ECONNABORTED, state, ENOTDIR, removeTimer, LocCreateIndex, setTimer, ETIME, EBADE, EDEADLK, items, asyncCheck, epochNanoSeconds, unregister2, Duration, ELNRNG, locked, join, millis, EMEDIUMTYPE, readError, sleepAsync, newFutureSeq, newAsyncEventQueue, InternalAsyncCallback, ENETUNREACH, get, ENOSYS, acquire, ELIBSCN, EIO, EROFS, AsyncEventQueueFullError, ELIBMAX, SrcLoc, EFBIG, EL2HLT, AsyncQueueFullError, EOPNOTSUPP, emit, FutureStr, poll, readerOverflow, flags, register2, LocCompleteIndex, newAsyncLock, days, ENOSTR, EADDRINUSE, one, AsyncSemaphoreError, size, newFuture, now, putNoWait, Nanosecond, wait, newAsyncEvent, ESTALE, Raising, Day, ENODATA, init, +, minutes, ERFKILL, cancelled, $, toException, EDEADLOCK, allFutures, MaxEventsCount, wait, read, raiseAsDefect, Millisecond, addLast, addReader2, failed, ENOTUNIQ, callback=, ENOTSOCK, ECONNREFUSED, high, ENOTNAM, nanos, addWriter2, toString, removeTimer, EL3HLT, join, closeHandle, EL3RST, EADV, *, ENAMETOOLONG, HttpTables, new, getInt, getLastString, isEmpty, getString, new, items, count, clear, getList, HttpTable, HttpTableRef, stringItems, contains, normalizeHeaderName, $, add, init, hasKeyOrPut, toList, add, set, init, getLastInt, ContentEncodingHeader, EDQUOT, milliseconds, EMLINK, milliseconds, EMFILE, $, release, fromNow, DateHeader, weeks, newAsyncQueue, addLastNoWait, id, FutureCompletedError, waitFor, EPROTONOSUPPORT, cancelAndWait, ExpectHeader, toString, removeTimer, ContentLengthHeader, race, $, ENOSPC, newHttpInterruptError, idleAsync, ENOKEY, HttpServerResponseTrackerName, Week, cancelSoon, awaitne, HttpRecoverableError, EREMOTE, EFAULT, epochSeconds, microseconds, AsyncEvent, weeks, cancelCallback=, ETOOMANYREFS, getContentEncoding, micros, HttpError, wait, ENETDOWN, EACCES, ContentDispositionHeader, bytesToString, EINVAL, full, QueryParamsFlag, EBADFD, seconds, join, UrlEncodedContentType, <=, init, completed, FutureBase, ==, ELIBBAD, HttpServerUnsecureConnectionTrackerName, getContentType, or, cancelSoon, ==, EILSEQ, allFutures, EADV, -, ==, location, addFirstNoWait, ConnectionHeader, ENOLCK, FutureSeq, cancelAndWait, EPROTO, HttpRequestError, value, ENODEV, FutureStr, ECHRNG, ERFKILL, setTimer, nanoseconds, closeWait, get, stringToBytes, addTimer, race, ENOTTY, EISNAM, init, +, FutureFlags, getGlobalDispatcher, ELIBEXEC, raiseHttpProtocolError, E2BIG, -=, AsyncSemaphoreError, AsyncQueueEmptyError, <, fastEpochTime, $, HttpProtocolError, read, LocationHeader, TrackerCounter, HeadersMark, async, EREMCHG, Finished, low, ProxyAuthorizationHeader, removeTimer, release, Duration, failed, HttpReadError, orImpl, EROFS, seconds, init, HttpServerSecureConnectionTrackerName, nanos, HttpCriticalError, HttpResultCode, Nanosecond, race, ENODATA, init, +, raiseHttpProtocolError, EAFNOSUPPORT, raiseHttpWriteError, ELIBSCN, ENOTNAM, nanos, isPersistent, closeHandle, ENOTUNIQ, getTransferEncodings, newFuture, popFirstNoWait, isCriticalError, raiseHttpInterruptError, closeSocket, ECONNRESET, contains, Second, getSrcLocation, FutureError, withTimeout, EREMOTEIO, HttpRequestHeadersTooLargeError, ENOENT, raiseHttpRequestBodyTooLargeError, setThreadDispatcher, EEXIST, ENOMSG, ESHUTDOWN, removeWriter2, [], EWOULDBLOCK, Finished, EHWPOISON, setGlobalDispatcher, TrackerBase, HttpResultMessage, AsyncEventQueue, addCallback, ESTRPIPE, EISCONN, callSoon, EBADF, microseconds, ETIMEDOUT, Future, queryParams, EL2NSYNC, ETIME, EL2HLT, EIDRM, removeReader2, futureContinue, ENOANO, raiseHttpReadError, AuthorizationHeader, raiseHttpConnectionError, register, ERANGE, done, popLastNoWait, ENONET, EPFNOSUPPORT, raiseHttpAddressError, EMSGSIZE, EBADMSG, ENOPROTOOPT, EDOTDOT, Minute, CancelledError, EOVERFLOW, ENOTEMPTY, TimerCallback, EADDRNOTAVAIL, wait, one, size, EUNATCH, newAsyncLock, div, ERESTART, availableSlots, newFutureStr, FuturePendingError, unregisterAndCloseFd, LocFinishIndex, newAsyncEvent, UserAgentHeader, ENOTBLK, race, InternalRaisesFuture, cancelSoon, cancel, micros, wait, unregister, EINPROGRESS, -, EDOM, EPIPE, AsyncLockError, getNoWait, len, EDESTADDRREQ, removeCallback, EAGAIN, FutureFlag, read, async, emit, ENXIO, HostHeader, noCancel, init, raiseHttpProtocolError, ECONNABORTED, state, EBFONT, [], EDEADLK, ENOEXEC, asyncCheck, locked, HttpRedirectError, ZeroDuration, []=, ENOSYS, EventQueueKey, ELIBMAX, EOPNOTSUPP, raiseHttpCriticalError, ENOSTR, one, MultipartContentType, Raising, popFirst, read, items, Millisecond, [], readError, []=, ECONNREFUSED, addWriter2, EL3HLT, join, readError, *, CallbackFunc, <=, EHOSTUNREACH, EHOSTDOWN, newHttpWriteError, ECANCELED, init, HttpServerRequestTrackerName, +=, completed, internalRaiseIfError, newInternalRaisesFuture, ESPIPE, LocationKind, SomeIntegerI64, complete, internalInitFutureBase, nanoseconds, ECOMM, PostMethods, init, millis, ENOTCONN, EBUSY, days, sleepAsync, +=, HttpState, HttpDisconnectError, isZero, NestedPoll, ENOMEM, addFirst, EKEYEXPIRED, EPERM, HttpConnectionError, AsyncCallback, HttpWriteError, newAsyncEventQueue, ESOCKTNOSUPPORT, AsyncQueue, EXDEV, EKEYREVOKED, encodeBasicAuth, hours, InfiniteDuration, clear, HttpMessage, HttpTransportError, ESRCH, fire, HttpUseClosedError, ENOMEDIUM, secs, getThreadDispatcher, waitFor, isSet, value, close, waitFor, epochNanoSeconds, ENOPKG, bytesToString, EBADE, len, getAsyncTimestamp, FutureState, EBADR, put, EKEYREJECTED, EISDIR, ESRMNT, HttpResponseError, ENAVAIL, error, AsyncError, EBADRQC, ENFILE, failed, mitems, ETXTBSY, withTimeout, flags, DispatcherHandle, ELIBACC, Day, getContentEncodings, minutes, KeyValueTuple, cancelAndWait, cancelAndWait, EBADSLT, ENETRESET, waitEvents, ThreadCallbackFunc, wait, getTransferEncoding, asyncSpawn, removeCallback, AsyncLock, init, addCallback, clearTimer, AsyncFD, ECHILD, HttpInterruptError, LocCreateIndex, RecoverableHttpAddressError, millis, EMEDIUMTYPE, sleepAsync, callback=, acquire, EIO, tryCancel, high, poll, days, ESTALE, minutes, toException, MaxEventsCount, wait, raiseAsDefect, addReader2, unregister2, callback=, high, newHttpReadError, CriticalHttpAddressError, toString, EINTR, fail, popLast, stringToBytes, HttpReadLimitError, isRecoverableError, internalRaiseIfError, fail, addTimer, race, Moment, EPROTOTYPE, AsyncExceptionError, HttpRequestBodyTooLargeError, ENOCSI, init, HttpAddressError, now, await, or, AsyncTimeoutError, ENOLINK, tryAcquire, TransferEncodingHeader, +, newDispatcher, internalFail, HttpInvalidUsageError, completed, handle, error, ELOOP, ENOSR, allFinished, PDispatcher, HttpRequestHeadersError, finished, low, -=, HttpResult, AcceptHeaderName, Hour, readerOverflow, addLast, asyncTimer, contains, Microsecond, pairs, EOWNERDEAD, ContentEncodingFlags, callSoon, EALREADY, addTimer, FutureDefect, ENOBUFS, <, one, raiseHttpRedirectError, cancelSoon, -, ENOTRECOVERABLE, ENOTDIR, hours, cancelAndSchedule, *, complete, EUSERS, EXFULL, EUCLEAN, $, stepsAsync, clear, EventQueueReader, secs, newHttpUseClosedError, read, waitFor, MaximumBodySizeError, newAsyncSemaphore, empty, AsyncSemaphore, allFutures, SrcLoc, raiseOsDefect, acquire, AsyncQueueFullError, ContentTypeHeader, wait, ELNRNG, ServerHeader, isInfinite, InternalAsyncCallback, ENETUNREACH, InternalFutureBase, AsyncEventQueueFullError, HttpRequestBodyError, register2, LocCompleteIndex, TransferEncodingFlags, EMULTIHOP, putNoWait, await, HttpAddressErrorType, EFBIG, cancelled, EDEADLOCK, allFutures, newFutureSeq, ENOTSOCK, raiseHttpDisconnectError, EADDRINUSE, removeTimer, EL3RST, ENAMETOOLONG, ContentEncodingHeader, createStreamServer, AsyncStreamError, createStreamServer, createStreamServer, fromNow, items, close, weeks, LocFinishIndex, id, FutureCompletedError, EPROTONOSUPPORT, createStreamServer, createStreamServer, ENOTBLK, AsyncStreamWriterVtbl, removeTimer, tryAcquire, race, ENOSPC, TransportUseClosedError, AsyncStreamState, idleAsync, ENOKEY, HttpServerResponseTrackerName, Week, awaitne, HttpRecoverableError, EFAULT, getUserData, weeks, ETOOMANYREFS, raiseAsyncStreamLimitError, localAddress, ==, micros, EACCES, EINVAL, QueryParamsFlag, len, raiseTransportOsError, finish, join, UrlEncodedContentType, <=, $, FutureBase, set, ELIBBAD, TransportLimitError, or, EILSEQ, allFutures, EADV, -, newAsyncStreamWriter, location, addFirstNoWait, new, availableSlots, close, ECHRNG, setTimer, closeWait, stringToBytes, $, init, createStreamServer, FutureFlags, getGlobalDispatcher, E2BIG, -=, contains, checkWriteEof, fastEpochTime, read, resolveTAddress, newHttpBodyReader, HttpUseClosedError, read, closeWait, LocationHeader, error, write, localAddress2, EREMCHG, SocketFlags, removeTimer, release, Duration, HttpReadError, initTAddress, EROFS, seconds, MultipartError, start, readerOverflow, HttpResultCode, atEof, race, +, raiseHttpProtocolError, DefaultStreamBufferSize, raiseHttpWriteError, createStreamServer, ELIBSCN, nanos, atEoM, isPersistent, atEoM, popFirstNoWait, isCriticalError, HttpServerRequestTrackerName, FutureError, getTransportTooManyError, init, ENOEXEC, contains, EREMOTEIO, MultiPart, noCancel, getLastInt, EEXIST, newInternalRaisesFuture, finish, ESHUTDOWN, removeWriter2, EWOULDBLOCK, finished, setGlobalDispatcher, TrackerBase, AsyncEventQueue, ESTRPIPE, $, callSoon, readUntil, close, write, cancelAndWait, getTransferEncoding, isEmpty, ETIME, contains, getDomain, EL2HLT, removeReader2, getBody, futureContinue, ENOANO, normalizeHeaderName, raiseHttpReadError, raiseHttpConnectionError, DefaultBacklogSize, register, BChar, done, init, completed, raiseHttpAddressError, EMSGSIZE, ENOSTR, EDOTDOT, readLine, EOVERFLOW, raiseTransportError, newAsyncStreamReader, AnyAddress6, ENOTEMPTY, EADDRNOTAVAIL, wait, getLastString, one, checkClosed, AnyAddress, EUNATCH, newAsyncLock, div, ERESTART, ThreadCallbackFunc, FuturePendingError, unregisterAndCloseFd, newAsyncQueue, ExpectHeader, race, micros, size, ContentDispositionHeader, AsyncStreamDefaultBufferSize, -, new, EDOM, EPIPE, len, shutdownWait, removeCallback, FutureFlag, read, resolveTAddress, ENXIO, raiseHttpProtocolError, ==, locked, HttpRedirectError, ZeroDuration, []=, finish, ENOSYS, EventQueueKey, ELIBMAX, EOPNOTSUPP, AuthorizationHeader, clearTimer, getList, getTransportError, newAsyncStreamReader, checkClosed, HttpResponseError, read, consume, ECONNREFUSED, join, <=, ECANCELED, stringItems, init, TransportAddress, complete, AsyncBufferRef, AddressFamily, nanoseconds, ECOMM, hasOverflow, PostMethods, init, closed, AsyncBuffer, ENOTCONN, setDualstack, ReadOnceProc, days, sleepAsync, initUdata, consume, StreamReaderLoop, AsyncStreamReaderVtbl, ENOMEM, EPERM, HttpWriteError, newAsyncEventQueue, DefaultDatagramBufferSize, ContentEncodingFlags, readMessage, write, EKEYREVOKED, hours, clear, clear, HttpMessage, fire, atEof, secs, allFutures, isAvailable, AsyncStreamRW, isSet, EAFNOSUPPORT, getTransportOsError, read, waitFor, ENOPKG, newAsyncStreamWriter, TransportIncompleteError, bytesToString, WriteItem, EBADE, MultiPartWriter, getAsyncTimestamp, FutureState, closeWait, DualStackType, new, nanoseconds, init, address, ENAVAIL, anyAddressFix, AsyncError, EBADRQC, failed, withTimeout, flags, ELIBACC, minutes, ReadMessagePredicate, AsyncStreamWriter, toException, init, EBADSLT, closed, TransportUseEofError, ENETRESET, waitEvents, closeWait, init, wait, remoteAddress, finishPart, init, AsyncFD, ECHILD, Raising, hasKeyOrPut, newAsyncStreamUseClosedError, [], WriteProc, AsyncStreamWriterTrackerName, getError, join, millis, callback=, HttpTable, EIO, write, FutureStr, poll, days, toString, ESTALE, raiseAsDefect, newAsyncStreamReader, consume, unregister2, init, high, CriticalHttpAddressError, EINTR, raiseAsyncStreamWriteEOFError, toHex, popLast, stringToBytes, transfer, StreamCallback, HttpReadLimitError, connect, fail, fromPipe, EPROTOTYPE, HttpRequestBodyTooLargeError, init, HttpAddressError, now, or, createStreamServer, StreamTransport, newAsyncStreamLimitError, init, newDispatcher, internalFail, readOnce, newAsyncStreamWriter, ServerFlags, TransportTooManyError, ENOSR, AsyncStreamReaderTrackerName, allFinished, resolveTAddress, closeWait, HttpRequestHeadersError, -=, AcceptHeaderName, stop2, writeFile, ENOMEDIUM, resolveTAddress, CallbackFunc, Microsecond, readMessage, callSoon, readUntil, write, TransportOsError, addTimer, closed, init, FutureDefect, ENOBUFS, one, raiseHttpRedirectError, -, read, toIpAddress, resolveTAddress, ENOTRECOVERABLE, ENOTDIR, hours, cancelAndSchedule, newHttpWriteError, ServerStatus, $, complete, EXFULL, HttpDisconnectError, clear, stepsAsync, getInt, value, raiseHttpDisconnectError, EventQueueReader, secs, value, read, waitFor, MaximumBodySizeError, TransportNoSupport, empty, closeWait, get, MultiPartReaderRef, raiseAsyncStreamIncompleteError, AsyncStream, init, addCallback, toSAddr, AsyncQueueFullError, write, TransportAbortedError, ContentTypeHeader, newAsyncStreamReader, ServerHeader, ENOCSI, AsyncStreamUseClosedError, InternalAsyncCallback, InternalFutureBase, getTransportUseClosedError, resolveTAddress, AsyncEventQueueFullError, atEof, resolveTAddress, register2, LocCompleteIndex, TransferEncodingFlags, initSimpleVtbl, EMULTIHOP, putNoWait, await, HttpAddressErrorType, EFBIG, TransportAddressError, cancelled, allFutures, closeWait, newFutureSeq, ENOTSOCK, TransportState, initSimpleVtbl, removeTimer, stop, EDQUOT, milliseconds, EMLINK, milliseconds, release, unregister, getTransportOsError, read, waitFor, TransferEncodingHeader, cancelAndWait, failed, setError, newAsyncStreamWriter, toString, init, ContentLengthHeader, newHttpInterruptError, initTAddress, beginPart, EREMOTE, epochSeconds, microseconds, AsyncEvent, cancelCallback=, TransportInitCallback, getContentEncoding, HttpError, wait, ENETDOWN, bytesToString, TransportFlags, full, EBADFD, seconds, AsyncStreamWriteError, HttpBodyWriter, AsyncStreamIncorrectDefect, completed, HttpServerSecureConnectionTrackerName, HttpServerUnsecureConnectionTrackerName, getContentType, cancelSoon, getPart, waitFor, getString, error, ConnectionHeader, ENOLCK, FutureSeq, cancelAndWait, EPROTO, getConnectionAbortedError, new, HttpRequestError, ENODEV, tryCancel, MultiPartReader, ERFKILL, add, init, running, addTimer, race, ENOTTY, EISNAM, +, ELIBEXEC, raiseHttpProtocolError, $, AsyncSemaphoreError, ServerCommand, AsyncQueueEmptyError, newAsyncStreamWriter, <, newHttpUseClosedError, fromPipe2, TrackerCounter, HeadersMark, start2, async, Finished, StreamServer, low, ProxyAuthorizationHeader, createStreamServer, AsyncStreamDefaultQueueSize, getUserData, localAddress, ==, init, nanos, HttpCriticalError, Nanosecond, close, ENODATA, init, failed, orImpl, ENOTNAM, closeHandle, ENOTUNIQ, getTransferEncodings, newFuture, closeSocket, ECONNRESET, [], Second, getSrcLocation, withTimeout, isEmpty, HttpRequestHeadersTooLargeError, initTAddress, HttpBodyReaderTrackerName, beginPart, stopped, ENOENT, AsyncStreamReadError, raiseHttpRequestBodyTooLargeError, []=, setThreadDispatcher, ENOMSG, HttpBodyWriterTrackerName, SomeIntegerI64, [], setDualstack, EHWPOISON, HttpResultMessage, TransportError, KeyValueTuple, EISCONN, getServerUseClosedError, newAsyncStreamWriteEOFError, EBADF, microseconds, ETIMEDOUT, Future, queryParams, EL2NSYNC, EIDRM, ERANGE, popLastNoWait, init, ENONET, EPFNOSUPPORT, EBADMSG, ENOPROTOOPT, closed, Minute, CancelledError, readPart, TimerCallback, init, AsyncStreamIncompleteError, WriteType, wait, closeWait, begin, newFutureStr, EMFILE, newAsyncEvent, UserAgentHeader, DateHeader, init, InternalRaisesFuture, cancelSoon, cancel, wait, EINPROGRESS, asyncSpawn, HttpTableRef, AsyncLockError, getNoWait, EDESTADDRREQ, EAGAIN, async, emit, items, getBytes, HostHeader, finishPart, init, ECONNABORTED, state, EDEADLK, asyncCheck, MultiPartSource, addCallback, raiseHttpCriticalError, one, MultipartContentType, begin, popFirst, ==, Millisecond, readError, addWriter2, EL3HLT, readError, *, MultiPartWriterRef, EHOSTUNREACH, EHOSTDOWN, getAutoAddress, +=, internalRaiseIfError, ESPIPE, LocationKind, internalInitFutureBase, host, join, millis, EBUSY, +=, HttpState, getMultipartBoundary, isZero, NestedPoll, EKEYEXPIRED, $, HttpConnectionError, AsyncCallback, finished, ESOCKTNOSUPPORT, AsyncQueue, getBodyStream, EXDEV, cancelSoon, encodeBasicAuth, InfiniteDuration, HttpTransportError, ESRCH, fromSAddr, getThreadDispatcher, write, SocketServer, close, addLastNoWait, epochNanoSeconds, getString, ==, StreamServerTrackerName, EBADR, put, EKEYREJECTED, EISDIR, StreamWriterLoop, ESRMNT, write, ENFILE, createStreamServer, getAutoAddresses, mitems, ETXTBSY, DispatcherHandle, Day, getContentEncodings, cancelAndWait, join, upload, newHttpBodyWriter, removeCallback, AsyncLock, getConnectionAbortedError, MultiPartWriterState, new, newAsyncStreamReader, consume, HttpInterruptError, LocCreateIndex, addReader2, StreamTransportTrackerName, RecoverableHttpAddressError, EMEDIUMTYPE, sleepAsync, getDomain, consumeBody, write, init, acquire, high, minutes, toException, PDispatcher, MaxEventsCount, wait, callback=, newHttpReadError, add, init, fail, running, readOnce, AsyncStreamLimitError, isRecoverableError, internalRaiseIfError, addTimer, race, raiseHttpInterruptError, Moment, addFirst, AsyncExceptionError, count, failed, await, AsyncTimeoutError, ENOLINK, finished, +, AsyncStreamWriteEOFError, init, StreamCallback2, HttpInvalidUsageError, completed, handle, readExactly, ELOOP, AsyncStreamReader, Finished, low, HttpResult, setErrorAndRaise, TransportKind, Hour, init, addLast, asyncTimer, pairs, EOWNERDEAD, connect, EALREADY, MultipartEOMError, initTAddress, newAsyncStreamWriter, <, cancelSoon, EBFONT, HttpBodyReader, *, readLine, EUSERS, EUCLEAN, accept, newAsyncStreamReader, newAsyncSemaphore, write, AsyncSemaphore, toList, SrcLoc, copyOut, raiseOsDefect, HttpTables, write, acquire, wait, ELNRNG, raiseAsyncStreamUseClosedError, isInfinite, ENETUNREACH, resolveTAddress, readExactly, HttpProtocolError, HttpRequestBodyError, ==, init, forget, EADDRINUSE, EDEADLOCK, write, newAsyncStreamIncompleteError, remoteAddress2, EL3RST, ENAMETOOLONG, EDQUOT, createStreamServer, milliseconds, AsyncStreamError, createStreamServer, EMLINK, createStreamServer, milliseconds, EMFILE, $, release, fromNow, close, weeks, newAsyncQueue, getTransportOsError, read, id, <=, FutureCompletedError, waitFor, EPROTONOSUPPORT, cancelAndWait, createStreamServer, failed, createStreamServer, setError, newAsyncStreamWriter, AsyncStreamWriterVtbl, removeTimer, race, $, ENOSPC, TransportUseClosedError, idleAsync, init, initTAddress, ENOKEY, Week, cancelSoon, awaitne, EREMOTE, EFAULT, epochSeconds, close, microseconds, AsyncEvent, weeks, cancelCallback=, ETOOMANYREFS, raiseAsyncStreamLimitError, TransportInitCallback, localAddress, StreamServerTrackerName, micros, wait, ENETDOWN, EACCES, EINVAL, full, EBADFD, seconds, AsyncStreamWriteError, read, raiseTransportOsError, finish, start, join, AsyncStreamIncorrectDefect, <=, init, completed, FutureBase, ==, $, ELIBBAD, TransportLimitError, or, cancelSoon, EILSEQ, allFutures, EADV, -, newAsyncStreamWriter, ==, location, addFirstNoWait, ENOLCK, FutureSeq, cancelAndWait, EPROTO, getConnectionAbortedError, value, ENODEV, close, ECHRNG, ERFKILL, setTimer, nanoseconds, init, closeWait, get, running, addTimer, race, ENOTTY, EISNAM, init, createStreamServer, ==, +, FutureFlags, getGlobalDispatcher, ELIBEXEC, E2BIG, -=, AsyncSemaphoreError, AsyncStreamReader, AsyncQueueEmptyError, newAsyncStreamWriter, <, checkWriteEof, fastEpochTime, resolveTAddress, $, read, PDispatcher, fromPipe2, TrackerCounter, write, localAddress2, start2, async, EREMCHG, Finished, StreamServer, SocketFlags, low, removeTimer, createStreamServer, release, Duration, failed, AsyncStreamDefaultQueueSize, initTAddress, getUserData, localAddress, orImpl, EROFS, seconds, init, readerOverflow, nanos, atEof, Nanosecond, race, ENODATA, init, +, EAFNOSUPPORT, DefaultStreamBufferSize, read, resolveTAddress, createStreamServer, failed, ELIBSCN, ENOTNAM, nanos, closeHandle, ENOTUNIQ, newFuture, popFirstNoWait, closeSocket, ECONNRESET, contains, Second, getSrcLocation, FutureError, getTransportTooManyError, init, withTimeout, EREMOTEIO, initTAddress, stopped, ENOENT, AsyncStreamReadError, setThreadDispatcher, EEXIST, ENOMSG, ESHUTDOWN, removeWriter2, [], setDualstack, EWOULDBLOCK, Finished, readMessage, setGlobalDispatcher, TrackerBase, AsyncEventQueue, addCallback, TransportError, ESTRPIPE, EISCONN, callSoon, getServerUseClosedError, newAsyncStreamWriteEOFError, close, EBADF, microseconds, ETIMEDOUT, ReadMessagePredicate, Future, EL2NSYNC, ETIME, getDomain, EL2HLT, EIDRM, removeReader2, futureContinue, ENOANO, DefaultBacklogSize, register, ERANGE, done, popLastNoWait, init, ENONET, EPFNOSUPPORT, EMSGSIZE, EBADMSG, ENOPROTOOPT, newAsyncStreamWriter, closed, EDOTDOT, one, Minute, CancelledError, readLine, EOVERFLOW, raiseTransportError, newAsyncStreamReader, AnyAddress6, ENOTEMPTY, TimerCallback, EADDRNOTAVAIL, wait, AsyncStreamIncompleteError, WriteType, checkClosed, size, EUNATCH, newAsyncLock, div, ERESTART, availableSlots, newFutureStr, upload, FuturePendingError, unregisterAndCloseFd, LocFinishIndex, newAsyncEvent, ENOTBLK, race, InternalRaisesFuture, cancelSoon, cancel, micros, wait, unregister, EINPROGRESS, -, remoteAddress, new, AsyncStreamDefaultBufferSize, EDOM, EPIPE, AsyncLockError, getNoWait, len, EDESTADDRREQ, shutdownWait, removeCallback, EAGAIN, FutureFlag, read, async, resolveTAddress, emit, ENXIO, noCancel, init, ECONNABORTED, state, EBFONT, [], EDEADLK, ENOEXEC, asyncCheck, locked, readError, ZeroDuration, []=, ENOSYS, EventQueueKey, ELIBMAX, EOPNOTSUPP, ENOSTR, one, getTransportError, newAsyncStreamReader, AsyncStream, checkClosed, Raising, popFirst, join, read, items, Millisecond, consume, [], []=, ECONNREFUSED, addWriter2, EL3HLT, join, readError, *, CallbackFunc, EHOSTUNREACH, EHOSTDOWN, ECANCELED, init, +=, completed, internalRaiseIfError, newInternalRaisesFuture, ESPIPE, LocationKind, TransportAddress, SomeIntegerI64, complete, AsyncBufferRef, internalInitFutureBase, AddressFamily, nanoseconds, host, ECOMM, init, closed, join, millis, AsyncBuffer, ENOTCONN, EBUSY, ReadOnceProc, days, sleepAsync, +=, initUdata, consume, isZero, StreamReaderLoop, AsyncStreamReaderVtbl, NestedPoll, ENOMEM, addFirst, EKEYEXPIRED, EPERM, AsyncCallback, fromPipe, newAsyncEventQueue, DefaultDatagramBufferSize, ESOCKTNOSUPPORT, EHWPOISON, AsyncQueue, EXDEV, EKEYREVOKED, toIpAddress, hours, TransportIncompleteError, InfiniteDuration, setDualstack, clear, ==, ESRCH, fire, fromSAddr, ENOMEDIUM, secs, getThreadDispatcher, write, isAvailable, AsyncStreamRW, waitFor, isSet, value, SocketServer, tryCancel, addLastNoWait, getTransportOsError, read, waitFor, epochNanoSeconds, ENOPKG, newAsyncStreamWriter, WriteItem, EBADE, len, getAsyncTimestamp, readUntil, FutureState, EBADR, close, put, EKEYREJECTED, init, EISDIR, address, StreamWriterLoop, ESRMNT, ENAVAIL, error, write, anyAddressFix, AsyncError, EBADRQC, ENFILE, createStreamServer, failed, getAutoAddresses, mitems, getUserData, ETXTBSY, withTimeout, flags, DispatcherHandle, ELIBACC, Day, minutes, DualStackType, cancelAndWait, AsyncStreamWriter, cancelAndWait, toException, init, EBADSLT, closed, TransportUseEofError, ENETRESET, waitEvents, ThreadCallbackFunc, AsyncStreamState, wait, asyncSpawn, removeCallback, AsyncLock, getConnectionAbortedError, init, addCallback, clearTimer, newAsyncStreamReader, AsyncFD, ECHILD, newAsyncStreamUseClosedError, consume, WriteProc, LocCreateIndex, AsyncStreamWriterTrackerName, ==, StreamTransportTrackerName, getError, join, millis, EMEDIUMTYPE, sleepAsync, getDomain, callback=, acquire, EIO, write, FutureStr, high, poll, days, ==, ESTALE, minutes, toException, MaxEventsCount, wait, raiseAsDefect, newAsyncStreamReader, consume, addReader2, unregister2, callback=, high, toString, EINTR, init, raiseAsyncStreamWriteEOFError, toHex, fail, popLast, transfer, running, AsyncStreamWriteEOFError, StreamCallback, readOnce, closeWait, AsyncStreamLimitError, internalRaiseIfError, connect, fail, addTimer, race, Moment, EPROTOTYPE, AsyncExceptionError, ENOCSI, init, now, await, or, AsyncTimeoutError, createStreamServer, ENOLINK, tryAcquire, finished, +, StreamTransport, newAsyncStreamLimitError, init, newDispatcher, StreamCallback2, internalFail, TransportFlags, completed, handle, readOnce, newAsyncStreamWriter, error, ServerFlags, TransportTooManyError, readExactly, ELOOP, ENOSR, AsyncStreamReaderTrackerName, allFinished, ServerCommand, resolveTAddress, closeWait, finished, low, -=, setErrorAndRaise, TransportKind, stop2, Hour, init, writeFile, atEof, resolveTAddress, addLast, asyncTimer, contains, Microsecond, pairs, EOWNERDEAD, connect, readMessage, callSoon, readUntil, EALREADY, TransportOsError, addTimer, initTAddress, FutureDefect, ENOBUFS, <, one, cancelSoon, -, resolveTAddress, ENOTRECOVERABLE, ENOTDIR, hours, wait, cancelAndSchedule, *, getAutoAddress, readLine, ServerStatus, complete, EUSERS, EXFULL, EUCLEAN, accept, $, stepsAsync, clear, EventQueueReader, secs, read, waitFor, newAsyncStreamReader, newAsyncSemaphore, TransportNoSupport, empty, closeWait, write, AsyncSemaphore, raiseAsyncStreamIncompleteError, allFutures, SrcLoc, copyOut, raiseOsDefect, toSAddr, acquire, AsyncQueueFullError, write, TransportAbortedError, wait, newAsyncStreamReader, ELNRNG, raiseAsyncStreamUseClosedError, isInfinite, finished, AsyncStreamUseClosedError, InternalAsyncCallback, ENETUNREACH, InternalFutureBase, readExactly, getTransportUseClosedError, resolveTAddress, AsyncEventQueueFullError, init, atEof, resolveTAddress, register2, LocCompleteIndex, forget, EADDRINUSE, initSimpleVtbl, EMULTIHOP, putNoWait, AnyAddress, await, EFBIG, TransportAddressError, cancelled, EDEADLOCK, allFutures, newFutureSeq, newAsyncStreamIncompleteError, ENOTSOCK, TransportState, remoteAddress2, initSimpleVtbl, removeTimer, stop, EL3RST, ENAMETOOLONG, EDQUOT, createStreamServer, milliseconds, AsyncStreamError, createStreamServer, EMLINK, createStreamServer, milliseconds, EMFILE, release, fromNow, close, weeks, newAsyncQueue, getTransportOsError, read, id, <=, FutureCompletedError, waitFor, EPROTONOSUPPORT, cancelAndWait, createStreamServer, failed, createStreamServer, setError, newAsyncStreamWriter, AsyncStreamWriterVtbl, BoundedBufferSize, removeTimer, race, ENOSPC, TransportUseClosedError, tryAcquire, idleAsync, init, initTAddress, ENOKEY, Week, cancelSoon, awaitne, EREMOTE, EFAULT, epochSeconds, tryCancel, microseconds, AsyncEvent, weeks, cancelCallback=, ETOOMANYREFS, raiseAsyncStreamLimitError, TransportInitCallback, localAddress, StreamServerTrackerName, ==, micros, init, wait, ENETDOWN, EACCES, newBoundedStreamReader, EINVAL, full, EBADFD, seconds, AsyncStreamWriteError, read, raiseTransportOsError, finish, mitems, join, AsyncStreamIncorrectDefect, <=, init, completed, FutureBase, ==, $, ELIBBAD, TransportLimitError, or, cancelSoon, EILSEQ, allFutures, waitFor, -, newAsyncStreamWriter, ==, location, addFirstNoWait, BoundCmp, ENOLCK, FutureSeq, cancelAndWait, EPROTO, getConnectionAbortedError, EDOM, value, ENODEV, FutureStr, ECHRNG, ERFKILL, setTimer, nanoseconds, init, closeWait, get, running, addTimer, race, ENOTTY, EISNAM, init, createStreamServer, ==, +, FutureFlags, getGlobalDispatcher, ELIBEXEC, E2BIG, -=, AsyncSemaphoreError, AsyncStreamReader, AsyncQueueEmptyError, newAsyncStreamWriter, <, checkWriteEof, fastEpochTime, BoundedStreamError, resolveTAddress, read, PDispatcher, fromPipe2, TrackerCounter, write, localAddress2, start2, async, EREMCHG, Finished, resolveTAddress, StreamServer, SocketFlags, low, removeTimer, createStreamServer, release, Duration, failed, AsyncStreamDefaultQueueSize, initTAddress, getUserData, localAddress, orImpl, EROFS, seconds, start, init, readerOverflow, $, nanos, atEof, Nanosecond, race, ENODATA, init, +, DefaultStreamBufferSize, read, createStreamServer, failed, ELIBSCN, ENOTNAM, nanos, closeHandle, ENOTUNIQ, newFuture, popFirstNoWait, closeSocket, ECONNRESET, contains, EAFNOSUPPORT, Second, getSrcLocation, FutureError, getTransportTooManyError, init, withTimeout, newBoundedStreamReader, EREMOTEIO, initTAddress, BoundedStreamReader, unregister, stopped, ENOENT, AsyncStreamReadError, []=, setThreadDispatcher, EEXIST, ENOMSG, ESHUTDOWN, removeWriter2, [], setDualstack, newBoundedStreamWriter, EWOULDBLOCK, $, Finished, readMessage, setGlobalDispatcher, TrackerBase, AsyncEventQueue, addCallback, TransportError, ESTRPIPE, EISCONN, callSoon, WriteItem, newAsyncStreamWriteEOFError, close, EBADF, microseconds, getUserData, ETIMEDOUT, ReadMessagePredicate, Future, EL2NSYNC, ETIME, getDomain, EL2HLT, EIDRM, removeReader2, futureContinue, ENOANO, DefaultBacklogSize, register, ERANGE, done, popLastNoWait, init, ENONET, completed, EMSGSIZE, EBADMSG, ENOPROTOOPT, newAsyncStreamWriter, closed, EDOTDOT, one, Minute, CancelledError, readLine, EOVERFLOW, raiseTransportError, newAsyncStreamReader, AnyAddress6, ENOTEMPTY, TimerCallback, EADDRNOTAVAIL, wait, AsyncStreamIncompleteError, WriteType, checkClosed, wait, EUNATCH, newAsyncLock, div, ERESTART, availableSlots, newFutureStr, upload, FuturePendingError, unregisterAndCloseFd, LocFinishIndex, popFirst, ENOTBLK, $, race, InternalRaisesFuture, cancelSoon, cancel, micros, size, EINPROGRESS, -, remoteAddress, new, AsyncStreamDefaultBufferSize, join, EPIPE, AsyncLockError, getNoWait, len, EDESTADDRREQ, shutdownWait, removeCallback, EAGAIN, FutureFlag, read, async, resolveTAddress, emit, ENXIO, noCancel, init, ECONNABORTED, state, EBFONT, [], EDEADLK, ENOEXEC, asyncCheck, locked, readError, ZeroDuration, []=, ENOSYS, *, bytesLeft, EventQueueKey, ELIBMAX, EOPNOTSUPP, ENOSTR, one, getTransportError, newAsyncStreamReader, AsyncStream, checkClosed, Raising, newAsyncEvent, join, read, items, Millisecond, consume, [], ECONNREFUSED, addWriter2, EL3HLT, join, readError, CallbackFunc, EHOSTUNREACH, EHOSTDOWN, ECANCELED, init, +=, completed, internalRaiseIfError, newInternalRaisesFuture, ESPIPE, LocationKind, TransportAddress, SomeIntegerI64, TransportFlags, complete, AsyncBufferRef, internalInitFutureBase, AddressFamily, nanoseconds, host, ECOMM, init, closed, join, millis, AsyncBuffer, ENOTCONN, EBUSY, ReadOnceProc, days, sleepAsync, +=, initUdata, consume, isZero, StreamReaderLoop, AsyncStreamReaderVtbl, NestedPoll, ENOMEM, EKEYEXPIRED, EPERM, newBoundedStreamReader, $, AsyncCallback, fromPipe, newAsyncEventQueue, DefaultDatagramBufferSize, ESOCKTNOSUPPORT, EHWPOISON, init, AsyncQueue, EXDEV, EKEYREVOKED, toIpAddress, hours, TransportIncompleteError, InfiniteDuration, setDualstack, clear, ==, ESRCH, fire, fromSAddr, atEof, secs, getThreadDispatcher, write, isAvailable, BoundedStreamIncompleteError, AsyncStreamRW, EADV, isSet, value, SocketServer, close, addLastNoWait, getTransportOsError, read, waitFor, epochNanoSeconds, ENOPKG, newAsyncStreamWriter, getServerUseClosedError, EBADE, len, getAsyncTimestamp, readUntil, FutureState, EBADR, close, ==, put, EKEYREJECTED, init, EISDIR, address, StreamWriterLoop, ESRMNT, ENAVAIL, error, write, anyAddressFix, AsyncError, EBADRQC, ENFILE, createStreamServer, failed, getAutoAddresses, ETXTBSY, withTimeout, flags, DispatcherHandle, ELIBACC, Day, minutes, DualStackType, cancelAndWait, AsyncStreamWriter, cancelAndWait, toException, init, EBADSLT, closed, TransportUseEofError, ENETRESET, waitEvents, ThreadCallbackFunc, init, MaxEventsCount, wait, asyncSpawn, removeCallback, AsyncLock, getConnectionAbortedError, init, addCallback, clearTimer, newAsyncStreamReader, AsyncFD, ECHILD, newAsyncStreamUseClosedError, consume, WriteProc, LocCreateIndex, AsyncStreamWriterTrackerName, StreamTransportTrackerName, getError, millis, EMEDIUMTYPE, sleepAsync, getDomain, callback=, init, acquire, EIO, AsyncQueueFullError, BoundedStreamRW, write, close, high, poll, days, ESTALE, minutes, toException, AsyncStreamState, wait, raiseAsDefect, newAsyncStreamReader, consume, addReader2, unregister2, callback=, init, high, toString, EINTR, init, raiseAsyncStreamWriteEOFError, closeWait, fail, popLast, transfer, running, AsyncStreamWriteEOFError, StreamCallback, readOnce, toHex, AsyncStreamLimitError, internalRaiseIfError, connect, fail, addTimer, race, Moment, addFirst, newBoundedStreamReader, EPROTOTYPE, AsyncExceptionError, ENOCSI, init, now, await, or, AsyncTimeoutError, createStreamServer, ENOLINK, finished, +, StreamTransport, newAsyncStreamLimitError, init, newDispatcher, init, StreamCallback2, internalFail, newBoundedStreamReader, EPFNOSUPPORT, handle, readOnce, newAsyncStreamWriter, error, ServerFlags, TransportTooManyError, readExactly, ELOOP, ENOSR, AsyncStreamReaderTrackerName, allFinished, ServerCommand, resolveTAddress, closeWait, finished, low, -=, setErrorAndRaise, TransportKind, stop2, Hour, init, writeFile, EventQueueReader, resolveTAddress, BoundedStreamWriter, addLast, asyncTimer, contains, Microsecond, pairs, EOWNERDEAD, connect, newBoundedStreamWriter, readMessage, callSoon, readUntil, EALREADY, TransportOsError, addTimer, init, initTAddress, FutureDefect, ENOBUFS, <, one, cancelSoon, -, resolveTAddress, ENOTRECOVERABLE, ENOTDIR, hours, AnyAddress, cancelAndSchedule, *, getAutoAddress, readLine, ServerStatus, complete, EUSERS, EXFULL, EUCLEAN, accept, newBoundedStreamReader, stepsAsync, clear, ENOMEDIUM, secs, read, waitFor, newAsyncStreamReader, newAsyncSemaphore, TransportNoSupport, empty, closeWait, BoundedStreamOverflowError, write, AsyncSemaphore, raiseAsyncStreamIncompleteError, allFutures, SrcLoc, copyOut, raiseOsDefect, init, toSAddr, acquire, write, TransportAbortedError, wait, newAsyncStreamReader, ELNRNG, raiseAsyncStreamUseClosedError, isInfinite, finished, AsyncStreamUseClosedError, InternalAsyncCallback, ENETUNREACH, InternalFutureBase, readExactly, getTransportUseClosedError, resolveTAddress, AsyncEventQueueFullError, init, atEof, resolveTAddress, register2, LocCompleteIndex, forget, remoteAddress2, initSimpleVtbl, EMULTIHOP, putNoWait, wait, await, EFBIG, TransportAddressError, cancelled, stop, EDEADLOCK, allFutures, newFutureSeq, newAsyncStreamIncompleteError, ENOTSOCK, TransportState, EADDRINUSE, initSimpleVtbl, removeTimer, EL3RST, ENAMETOOLONG, EDQUOT, createStreamServer, milliseconds, AsyncStreamError, createStreamServer, EMLINK, createStreamServer, milliseconds, EMFILE, release, fromNow, close, weeks, newAsyncQueue, getTransportOsError, read, id, <=, FutureCompletedError, waitFor, EPROTONOSUPPORT, cancelAndWait, createStreamServer, failed, createStreamServer, setError, newAsyncStreamWriter, AsyncStreamWriterVtbl, ChunkedStreamError, removeTimer, race, ENOSPC, TransportUseClosedError, tryAcquire, idleAsync, init, initTAddress, ENOKEY, Week, cancelSoon, awaitne, EREMOTE, EFAULT, epochSeconds, tryCancel, microseconds, AsyncEvent, weeks, cancelCallback=, ETOOMANYREFS, raiseAsyncStreamLimitError, TransportInitCallback, localAddress, StreamServerTrackerName, ==, micros, wait, ENETDOWN, EACCES, EINVAL, full, EBADFD, seconds, AsyncStreamWriteError, read, raiseTransportOsError, finish, mitems, join, AsyncStreamIncorrectDefect, <=, init, completed, FutureBase, ==, $, ELIBBAD, TransportLimitError, or, cancelSoon, EILSEQ, allFutures, waitFor, -, newAsyncStreamWriter, ==, location, addFirstNoWait, ENOLCK, FutureSeq, cancelAndWait, EPROTO, getConnectionAbortedError, EDOM, value, ENODEV, FutureStr, ECHRNG, ERFKILL, setTimer, nanoseconds, init, closeWait, get, running, addTimer, race, ENOTTY, EISNAM, init, createStreamServer, ==, +, FutureFlags, getGlobalDispatcher, ELIBEXEC, E2BIG, -=, AsyncSemaphoreError, AsyncStreamReader, AsyncQueueEmptyError, newAsyncStreamWriter, <, checkWriteEof, fastEpochTime, resolveTAddress, read, PDispatcher, fromPipe2, TrackerCounter, write, localAddress2, start2, async, EREMCHG, Finished, resolveTAddress, StreamServer, SocketFlags, low, removeTimer, createStreamServer, release, Duration, failed, hexValue, AsyncStreamDefaultQueueSize, initTAddress, getUserData, localAddress, orImpl, EROFS, seconds, start, init, readerOverflow, $, nanos, atEof, Nanosecond, ChunkedStreamWriter, race, ENODATA, init, +, DefaultStreamBufferSize, read, createStreamServer, failed, ELIBSCN, ENOTNAM, nanos, closeHandle, ENOTUNIQ, newFuture, popFirstNoWait, closeSocket, ECONNRESET, contains, EAFNOSUPPORT, ChunkedStreamReader, Second, getSrcLocation, FutureError, getTransportTooManyError, init, withTimeout, EREMOTEIO, initTAddress, unregister, stopped, ENOENT, AsyncStreamReadError, []=, setThreadDispatcher, EEXIST, ENOMSG, ESHUTDOWN, removeWriter2, [], setDualstack, EWOULDBLOCK, $, Finished, readMessage, setGlobalDispatcher, TrackerBase, AsyncEventQueue, addCallback, TransportError, ESTRPIPE, EISCONN, callSoon, WriteItem, newAsyncStreamWriteEOFError, close, EBADF, microseconds, getUserData, ETIMEDOUT, ReadMessagePredicate, Future, EL2NSYNC, ETIME, getDomain, EL2HLT, EIDRM, removeReader2, futureContinue, ENOANO, ChunkedStreamIncompleteError, DefaultBacklogSize, register, ERANGE, done, popLastNoWait, init, ENONET, completed, EMSGSIZE, EBADMSG, ENOPROTOOPT, newChunkedStreamWriter, newAsyncStreamWriter, closed, EDOTDOT, one, ChunkedStreamProtocolError, Minute, CancelledError, readLine, EOVERFLOW, raiseTransportError, newAsyncStreamReader, AnyAddress6, ENOTEMPTY, TimerCallback, EADDRNOTAVAIL, wait, AsyncStreamIncompleteError, WriteType, checkClosed, wait, EUNATCH, newAsyncLock, div, ERESTART, availableSlots, newFutureStr, upload, FuturePendingError, unregisterAndCloseFd, LocFinishIndex, popFirst, ENOTBLK, $, race, InternalRaisesFuture, cancelSoon, cancel, micros, size, EINPROGRESS, -, remoteAddress, new, AsyncStreamDefaultBufferSize, join, EPIPE, AsyncLockError, getNoWait, len, EDESTADDRREQ, shutdownWait, removeCallback, EAGAIN, FutureFlag, read, async, resolveTAddress, emit, ENXIO, noCancel, init, ECONNABORTED, state, EBFONT, [], EDEADLK, ENOEXEC, asyncCheck, locked, readError, ZeroDuration, []=, ENOSYS, *, EventQueueKey, ELIBMAX, EOPNOTSUPP, ENOSTR, one, getTransportError, newAsyncStreamReader, AsyncStream, checkClosed, Raising, newAsyncEvent, join, read, items, Millisecond, consume, [], ECONNREFUSED, addWriter2, EL3HLT, join, readError, CallbackFunc, EHOSTUNREACH, EHOSTDOWN, ECANCELED, init, +=, completed, internalRaiseIfError, newInternalRaisesFuture, ESPIPE, LocationKind, TransportAddress, SomeIntegerI64, TransportFlags, complete, AsyncBufferRef, internalInitFutureBase, AddressFamily, nanoseconds, host, ECOMM, init, closed, join, millis, AsyncBuffer, ENOTCONN, EBUSY, ReadOnceProc, days, sleepAsync, +=, initUdata, consume, isZero, StreamReaderLoop, AsyncStreamReaderVtbl, NestedPoll, ENOMEM, EKEYEXPIRED, EPERM, $, AsyncCallback, fromPipe, newAsyncEventQueue, DefaultDatagramBufferSize, ESOCKTNOSUPPORT, EHWPOISON, init, AsyncQueue, EXDEV, EKEYREVOKED, toIpAddress, hours, TransportIncompleteError, InfiniteDuration, setDualstack, clear, ==, ESRCH, fire, fromSAddr, atEof, secs, getThreadDispatcher, write, isAvailable, AsyncStreamRW, EADV, isSet, value, SocketServer, close, addLastNoWait, getTransportOsError, read, waitFor, epochNanoSeconds, ENOPKG, newAsyncStreamWriter, getServerUseClosedError, EBADE, len, getAsyncTimestamp, readUntil, FutureState, EBADR, close, ==, put, EKEYREJECTED, init, EISDIR, address, StreamWriterLoop, ESRMNT, ENAVAIL, error, write, anyAddressFix, AsyncError, EBADRQC, ENFILE, createStreamServer, failed, getAutoAddresses, ETXTBSY, withTimeout, flags, DispatcherHandle, ELIBACC, Day, minutes, DualStackType, cancelAndWait, AsyncStreamWriter, cancelAndWait, toException, init, EBADSLT, closed, TransportUseEofError, ENETRESET, waitEvents, ThreadCallbackFunc, MaxEventsCount, wait, asyncSpawn, removeCallback, AsyncLock, getConnectionAbortedError, init, addCallback, clearTimer, newAsyncStreamReader, AsyncFD, ECHILD, newAsyncStreamUseClosedError, consume, WriteProc, LocCreateIndex, AsyncStreamWriterTrackerName, StreamTransportTrackerName, getError, millis, EMEDIUMTYPE, sleepAsync, getDomain, callback=, init, acquire, EIO, AsyncQueueFullError, write, close, high, poll, days, ESTALE, minutes, toException, AsyncStreamState, wait, raiseAsDefect, newAsyncStreamReader, consume, addReader2, unregister2, callback=, init, high, toString, EINTR, init, raiseAsyncStreamWriteEOFError, closeWait, fail, popLast, transfer, running, AsyncStreamWriteEOFError, StreamCallback, readOnce, toHex, AsyncStreamLimitError, internalRaiseIfError, newChunkedStreamReader, connect, fail, addTimer, race, Moment, addFirst, EPROTOTYPE, AsyncExceptionError, ENOCSI, init, now, await, or, AsyncTimeoutError, createStreamServer, ENOLINK, finished, +, StreamTransport, newAsyncStreamLimitError, init, newDispatcher, StreamCallback2, internalFail, EPFNOSUPPORT, handle, readOnce, newAsyncStreamWriter, error, ServerFlags, TransportTooManyError, readExactly, ELOOP, ENOSR, AsyncStreamReaderTrackerName, allFinished, ServerCommand, resolveTAddress, closeWait, finished, low, -=, setErrorAndRaise, TransportKind, stop2, Hour, init, writeFile, EventQueueReader, resolveTAddress, addLast, asyncTimer, contains, newChunkedStreamWriter, Microsecond, newChunkedStreamReader, pairs, EOWNERDEAD, connect, readMessage, callSoon, readUntil, EALREADY, TransportOsError, addTimer, init, initTAddress, FutureDefect, ENOBUFS, <, one, cancelSoon, -, resolveTAddress, ENOTRECOVERABLE, ENOTDIR, hours, AnyAddress, cancelAndSchedule, *, getAutoAddress, readLine, ServerStatus, complete, EUSERS, EXFULL, EUCLEAN, accept, stepsAsync, clear, ENOMEDIUM, secs, read, waitFor, newAsyncStreamReader, newAsyncSemaphore, TransportNoSupport, empty, closeWait, write, AsyncSemaphore, raiseAsyncStreamIncompleteError, allFutures, SrcLoc, copyOut, raiseOsDefect, toSAddr, acquire, write, TransportAbortedError, wait, newAsyncStreamReader, ELNRNG, raiseAsyncStreamUseClosedError, isInfinite, finished, AsyncStreamUseClosedError, InternalAsyncCallback, ENETUNREACH, InternalFutureBase, readExactly, getTransportUseClosedError, resolveTAddress, AsyncEventQueueFullError, init, atEof, resolveTAddress, register2, LocCompleteIndex, forget, remoteAddress2, initSimpleVtbl, EMULTIHOP, putNoWait, wait, await, EFBIG, TransportAddressError, cancelled, stop, EDEADLOCK, allFutures, newFutureSeq, newAsyncStreamIncompleteError, ENOTSOCK, TransportState, EADDRINUSE, initSimpleVtbl, removeTimer, EL3RST, ENAMETOOLONG, TransportAddress, ServerFlags, $, $, $, $, $, $, ==, ==, ==, ==, ==, ==

Made with Nim. Generated: 2026-09-02 18:02:31 UTC