node-libcurl

constructor

constructor(cloneHandle?: Easy);

• Parameter cloneHandle

  `Easy` handle that should be used instead of creating a new one.

property chunks

protected chunks: Buffer[];

• Stores current response payload.

  This will not store anything in case `NoDataStorage` flag is enabled

property chunksLength

protected chunksLength: number;

• Current response length.

  Will always be zero in case `NoDataStorage` flag is enabled

property defaultUserAgent

static defaultUserAgent: string;

• This is the default user agent that is going to be used on all Curl instances.

  You can overwrite this in a per instance basis, calling curlHandle.setOpt('USERAGENT', 'my-user-agent/1.0'), or by directly changing this property so it affects all newly created Curl instances.

  To disable this behavior set this property to null.

property features

protected features: CurlFeature;

• Currently enabled features.

  See `enable` and `disable`

property getCount

static getCount: () => number;

• Returns the number of handles currently open in the internal `Multi` handle being used.

property getVersion

static getVersion: () => string;

• Returns libcurl version string.

  The string shows which libraries libcurl was built with and their versions, example:

  libcurl/7.69.1-DEV OpenSSL/1.1.1d zlib/1.2.11 WinIDN libssh2/1.9.0_DEV nghttp2/1.40.0

property getVersionInfo

static getVersionInfo: () => import('./types').CurlVersionInfoNativeBindingObject;

• Returns an object with a representation of the current libcurl version and their features/protocols.

  This is basically [curl_version_info()](https://curl.haxx.se/libcurl/c/curl_version_info.html)

property getVersionInfoString

static getVersionInfoString: () => string;

• Returns a string that looks like the one returned by

  curl -V

  Example:

  Version: libcurl/7.69.1-DEV OpenSSL/1.1.1d zlib/1.2.11 WinIDN libssh2/1.9.0_DEV nghttp2/1.40.0
  Protocols: dict, file, ftp, ftps, gopher, http, https, imap, imaps, ldap, ldaps, pop3, pop3s, rtsp, scp, sftp, smb, smbs, smtp, smtps, telnet, tftp
  Features: AsynchDNS, IDN, IPv6, Largefile, SSPI, Kerberos, SPNEGO, NTLM, SSL, libz, HTTP2, HTTPS-proxy

property globalCleanup

static globalCleanup: () => void;

• Calls [curl_global_cleanup()](http://curl.haxx.se/libcurl/c/curl_global_cleanup.html)

  This is automatically called when the process is exiting.

  Deprecated

  Does nothing, do not call. This is called by the addon itself when the environment is being unloaded.

property globalInit

static globalInit: () => void;

• Calls [curl_global_init()](http://curl.haxx.se/libcurl/c/curl_global_init.html).

  For **flags** see the the enum `CurlGlobalInit`.

  This is automatically called when the addon is loaded, and there is no way to disable it.

  This is a no-op now, and the call itself is deprecated.

  Deprecated

property handle

readonly handle: Easy;

• The internal Easy handle being used

property headerChunks

protected headerChunks: Buffer[];

• Stores current headers payload.

  This will not store anything in case `NoDataStorage` flag is enabled

property headerChunksLength

protected headerChunksLength: number;

• Current headers length.

  Will always be zero in case `NoDataStorage` flag is enabled

property id

readonly id: number;

• Returns the unique ID of the Easy handle.

  The value is unique across threads.

property info

static info: CurlInfo;

• This is a object with members resembling the CURLINFO_* libcurl constants.

  It can be used with `Easy#getInfo` or `Curl#getInfo`.

  See the official documentation of [curl_easy_getinfo()](http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html) for reference.

  CURLINFO_EFFECTIVE_URL becomes Curl.info.EFFECTIVE_URL

property isOpen

readonly isOpen: boolean;

• Whether this instance is closed or not (`close()` was called).

  Make sure to not change their value, otherwise unexpected behavior would happen.

property isRunning

isRunning: boolean;

• Whether this instance is running or not (`perform()` was called).

  Make sure to not change their value, otherwise unexpected behavior would happen.

  This is marked as protected only with the TSDoc to not cause a breaking change.

property isVersionGreaterOrEqualThan

static isVersionGreaterOrEqualThan: (
    x: number,
    y: number,
    z?: number
) => boolean;

• Useful if you want to check if the current libcurl version is greater or equal than another one.

  Parameter x

  major

  Parameter y

  minor

  Parameter z

  patch

property multiInstance

protected multiInstance?: Multi;

• Optional Multi instance to use for performing requests. If not set, uses the default shared Multi instance.

property nextPauseFlags

protected nextPauseFlags: CurlPause;

property option

static option: CurlOption;

• This is a object with members resembling the CURLOPT_* libcurl constants.

  It can be used with `Easy#setOpt` or `Curl#setOpt`.

  See the official documentation of [curl_easy_setopt()](http://curl.haxx.se/libcurl/c/curl_easy_setopt.html) for reference.

  CURLOPT_URL becomes Curl.option.URL

property readFunctionStream

protected readFunctionStream: any;

property streamContinueNext

protected streamContinueNext: boolean;

property streamError

protected streamError: false | Error;

property streamPauseNext

protected streamPauseNext: boolean;

property streamPendingReadSize

protected streamPendingReadSize: number;

property streamReadFunctionCallbacksToClean

protected streamReadFunctionCallbacksToClean: [
    Readable,
    string,
    (...args: any[]) => void
][];

property streamReadFunctionPaused

protected streamReadFunctionPaused: boolean;

property streamReadFunctionShouldEnd

protected streamReadFunctionShouldEnd: boolean;

property streamReadFunctionShouldPause

protected streamReadFunctionShouldPause: boolean;

property streamUserSuppliedProgressFunction

protected streamUserSuppliedProgressFunction: (
    this: Easy,
    dltotal: number,
    dlnow: number,
    ultotal: number,
    ulnow: number
) => number;

property streamWriteFunctionHighWaterMark

protected streamWriteFunctionHighWaterMark: number;

property VERSION_NUM

static VERSION_NUM: number;

• Integer representing the current libcurl version.

  It was built the following way:

  <8 bits major number> | <8 bits minor number> | <8 bits patch number>.

  Version 7.69.1 is therefore returned as 0x074501 / 476417

property writeFunctionStream

protected writeFunctionStream: any;

method cleanupReadFunctionStreamEvents

protected cleanupReadFunctionStreamEvents: () => void;

• When uploading a stream (by calling `setUploadStream`) some event listeners are attached to the stream instance. This will remove them so our callbacks are not called anymore.

method close

close: () => void;

• Close this handle.

  **NOTE:** After closing the handle, it must not be used anymore. Doing so will throw an error.

  Official libcurl documentation: [curl_easy_cleanup()](http://curl.haxx.se/libcurl/c/curl_easy_cleanup.html)

method defaultHeaderFunction

protected defaultHeaderFunction: (
    chunk: Buffer,
    size: number,
    nmemb: number
) => number;

• This is the default callback passed to `setOpt('HEADERFUNCTION', cb)`.

method defaultWriteFunction

protected defaultWriteFunction: (
    chunk: Buffer,
    size: number,
    nmemb: number
) => number;

• This is the default callback passed to `setOpt('WRITEFUNCTION', cb)`.

method defaultWriteFunctionStreamBased

protected defaultWriteFunctionStreamBased: (
    chunk: Buffer,
    size: number,
    nmemb: number
) => number;

• This is used by the default callback passed to `setOpt('WRITEFUNCTION', cb)` when the feature to stream response is enabled.

method disable

disable: (bitmask: CurlFeature) => this;

• Disables a feature, must not be used while a request is running.

  Use `CurlFeature` for predefined constants.

method dupHandle

dupHandle: (shouldCopyEventListeners?: boolean) => Curl;

• Duplicate this handle with all their options. Keep in mind that, by default, this also means all event listeners.

  Official libcurl documentation: [curl_easy_duphandle()](http://curl.haxx.se/libcurl/c/curl_easy_duphandle.html)

  Parameter shouldCopyEventListeners

  If you don't want to copy the event listeners, set this to false.

method enable

enable: (bitmask: CurlFeature) => this;

• Enables a feature, must not be used while a request is running.

  Use `CurlFeature` for predefined constants.

method getHeaders

protected getHeaders: () => Buffer<ArrayBuffer> | HeaderInfo[];

• Returns headers from the current stored chunks - if any

method onEnd

onEnd: () => void;

• Callback called when this handle has finished the request.

  This is called from the internal callback we use with the `onMessage` method of the global `Multi` handle used by all Curl instances.

  This should not be called in any other way.

method onError

onError: (error: Error, errorCode: CurlCode) => void;

• Callback called when an error is thrown on this handle.

  This is called from the internal callback we use with the `onMessage` method of the global `Multi` handle used by all Curl instances.

method pause

pause: (bitmask: CurlPause) => this;

• Use this function to pause / unpause a connection.

  The bitmask argument is a set of bits that sets the new state of the connection.

  Use `CurlPause` for predefined constants.

  Official libcurl documentation: [curl_easy_pause()](http://curl.haxx.se/libcurl/c/curl_easy_pause.html)

method perform

perform: () => this;

• Add this instance to the processing queue. This method should be called only one time per request, otherwise it will throw an error.

  Remarks

  This basically calls the `Multi#addHandle` method.

method reset

reset: () => this;

• Reset this handle options to their defaults.

  This will put the handle in a clean state, as if it was just created.

  Official libcurl documentation: [curl_easy_reset()](http://curl.haxx.se/libcurl/c/curl_easy_reset.html)

method resetInternalState

protected resetInternalState: () => void;

• This is used to reset a few properties to their pre-request state.

method setMimePost

setMimePost: (parts: CurlyMimePart[]) => this;

• Build and set a MIME structure from a declarative configuration.

  This method delegates to `Easy.setMimePost` on the internal `Easy` handle, which builds a CurlMime structure from the provided part specifications and sets it using the MIMEPOST option.

  Available since libcurl 7.56.0.

  Parameter parts

  Array of MIME part specifications

  Returns

  This Curl instance for method chaining

method setMulti

setMulti: (multi: Multi | undefined) => this;

• Sets a custom Multi instance to use for performing requests.

  This allows for HTTP/2 connection isolation - each Multi instance maintains its own connection pool, ensuring requests don't share connections between different Multi instances.

  Parameter multi

  The Multi instance to use, or undefined to use the default shared instance

  Returns

  This Curl instance for method chaining

  Example 1

  const multi = new Multi()
  const curl = new Curl()
  curl.setMulti(multi)
  curl.setOpt('URL', 'https://example.com')
  curl.perform()

method setProgressCallback

setProgressCallback: (
    cb: (
        dltotal: number,
        dlnow: number,
        ultotal: number,
        ulnow: number
    ) => number
) => this;

• The option XFERINFOFUNCTION was introduced in curl version 7.32.0, versions older than that should use PROGRESSFUNCTION. If you don't want to mess with version numbers you can use this method, instead of directly calling `Curl#setOpt`.

  NOPROGRESS should be set to false to make this function actually get called.

method setStreamProgressCallback

setStreamProgressCallback: (cb: CurlOptionValueType['xferInfoFunction']) => this;

• This sets the callback to be used as the progress function when using any of the stream features.

  This is needed because when this Curl instance is enabled to use streams for upload/download, it needs to set the libcurl progress function option to an internal function.

  If you are using any of the streams features, do not overwrite the progress callback to something else, be it using `setOpt` or `setProgressCallback`, as this would cause undefined behavior.

  If are using this callback, there is no need to set the NOPROGRESS option to false (as you normally would).

method setStreamResponseHighWaterMark

setStreamResponseHighWaterMark: (highWaterMark: number | null) => this;

• Set the param to null to use the Node.js default value.

  Parameter highWaterMark

  This will passed directly to the Readable stream created to be returned as the response'

  Remarks

  Only useful when the `StreamResponse` feature flag is enabled.

method setUploadStream

setUploadStream: (stream: Readable | null) => this;

• This will set an internal READFUNCTION callback that will read all the data from this stream.

  One usage for that is to upload data directly from streams. Example:

   const curl = new Curl()
   curl.setOpt('URL', 'https://some-domain/upload')
   curl.setOpt('UPLOAD', true)
   // so we do not need to set the content length
   curl.setOpt('HTTPHEADER', ['Transfer-Encoding: chunked'])
  
   const filePath = './test.zip'
   const stream = fs.createReadStream(filePath)
   curl.setUploadStream(stream)
  
   curl.setStreamProgressCallback(() => {
     // this will use the default progress callback from libcurl
     return CurlProgressFunc.Continue
   })
  
   curl.on('end', (statusCode, data) => {
     console.log('\n'.repeat(5))
     // data length should be 0, as it was sent using the response stream
     console.log(
       `curl - end - status: ${statusCode} - data length: ${data.length}`,
     )
     curl.close()
   })
   curl.on('error', (error, errorCode) => {
     console.log('\n'.repeat(5))
     console.error('curl - error: ', error, errorCode)
     curl.close()
   })
   curl.perform()

  Multiple calls with the same stream that was previously set has no effect.

  Setting this to null will remove the READFUNCTION callback and disable this behavior.

  Remarks

  This option is reset after each request, so if you want to upload the same data again using the same Curl instance, you will need to provide a new stream.

  Make sure your libcurl version is greater than or equal 7.69.1. Versions older than that one are not reliable for streams usage.

method streamModeProgressFunction

protected streamModeProgressFunction: (
    dltotal: number,
    dlnow: number,
    ultotal: number,
    ulnow: number
) => number;

• The internal function passed to PROGRESSFUNCTION (XFERINFOFUNCTION on most recent libcurl versions) when using any of the stream features.

method upkeep

upkeep: () => this;

• Perform any connection upkeep checks.

  Official libcurl documentation: [curl_easy_upkeep()](http://curl.haxx.se/libcurl/c/curl_easy_upkeep.html)

constructor

constructor(message: string, code: CurlCode, errorOptions?: ErrorOptions);

property code

readonly code: CurlCode;

property name

static readonly name: string;

property name

static readonly name: string;

constructor

constructor(handle: Easy | Curl);

• Creates a new MIME structure associated with an Easy or Curl handle.

  Parameter handle

  The Easy or Curl handle this MIME structure will be associated with

  Example 1

  const curl = new Curl()
  const mime = new CurlMime(curl)

  Example 2

  const easy = new Easy()
  const mime = new CurlMime(easy)

method addPart

addPart: () => CurlMimePart;

• Adds a new empty part to this MIME structure.

  Returns

  A new CurlMimePart instance that can be configured

  Example 1

  const mime = new CurlMime(curl)
  mime
   .addPart()
   .setName('field_name')
   .setData('field_value')

  See Also

  • curl_mime_addpart

method setData

setData: (data: string | Buffer | null) => this;

• Sets the data content for this MIME part from a string or Buffer.

  Parameter data

  The data as a string or Buffer, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  The data is copied internally, so it's safe to reuse or modify the buffer after calling this method.

  Example 1

  part
    .setName('file')
    .setData('Hello World')
    .setType('text/plain')
  // or
  part
    .setName('file')
    .setData(Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
    .setType('text/plain')

  See Also

  • curl_mime_data

method setDataCallback

setDataCallback: (size: number, callbacks: MimeDataCallbacks) => this;

• Sets a callback-based mechanism for supplying part content dynamically.

  Parameter size

  Expected total size in bytes, -1 works for unknown sizes

  Parameter callbacks

  Object containing read, seek (optional), and free (optional) callbacks

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  Use this for streaming or dynamically generated content. The read callback will be called multiple times to supply data chunks. Return null from the read callback to signal EOF.

  Example 1

  let currentOffset = 0
  const data = Buffer.from('Large data to stream...')
  
  part
    .setName('stream')
    .setDataCallback(data.length, {
      read: (size) => {
        if (currentOffset >= data.length) return null  // EOF
        const chunk = data.slice(currentOffset, currentOffset + size)
        currentOffset += chunk.length
        return chunk
      },
      seek: (offset, origin) => {
        if (origin === 0) {  // SEEK_SET
          currentOffset = offset
          return true
        }
        return false
      }
    })

  See Also

  • curl_mime_data_cb

method setDataStream

setDataStream: (stream: Readable, unpause: () => void, size?: number) => this;

• Sets the data content for this MIME part from a Node.js Readable stream.

  Parameter stream

  Node.js Readable stream to read data from

  Parameter unpause

  Callback function to unpause the transfer when data becomes available

  Parameter size

  Optional expected total size in bytes (for Content-Length header)

  Returns

  this for method chaining

  Throws

  {Error} Throws if stream emits an error

  Remarks

  This method provides a wrapper around setDataCallback for working with Node.js streams. The stream is kept in paused mode and data is read synchronously when curl requests it. When no data is available, the transfer is paused using CurlReadFunc.Pause, and the unpause callback is invoked when data becomes available to resume the transfer.

  The unpause function should unpause the curl handle's receive operation, typically by calling handle.pause(handle.pauseFlags & ~CurlPause.Recv).

  For very large files, consider using setFileData instead, as it streams directly from disk without going through Node.js streams.

  Example 1

  Stream from file with unpause:

  import { createReadStream } from 'fs'
  import { CurlPause } from 'node-libcurl'
  
  const stream = createReadStream('/path/to/file.txt')
  const curl = new Curl()
  const mime = new CurlMime(curl)
  
  mime
    .addPart()
    .setName('document')
    .setDataStream(stream, () => {
      curl.pause(curl.handle.pauseFlags & ~CurlPause.Recv)
    })
    .setType('text/plain')

  Example 2

  Stream with known size:

  import { createReadStream, statSync } from 'fs'
  import { CurlPause } from 'node-libcurl'
  
  const filepath = '/path/to/file.txt'
  const size = statSync(filepath).size
  const stream = createReadStream(filepath)
  const curl = new Curl()
  const mime = new CurlMime(curl)
  
  mime
    .addPart()
    .setName('document')
    .setDataStream(
      stream,
      () => curl.pause(curl.handle.pauseFlags & ~CurlPause.Recv),
      size
    )

method setEncoder

setEncoder: (
    encoding: 'binary' | '8bit' | '7bit' | 'base64' | 'quoted-printable' | null
) => this;

• Sets the content transfer encoding for this part.

  Parameter encoding

  Encoding scheme: 'binary', '8bit', '7bit', 'base64', 'quoted-printable', or null to disable

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  - 'binary': No encoding, header added - '8bit': No encoding, header added - '7bit': Validates 7-bit compliance - 'base64': Base64 encoding - 'quoted-printable': Quoted-printable encoding

  Do NOT use encoding with multipart content (subparts).

  Example 1

  part
    .setName('data')
    .setData(binaryData)
    .setEncoder('base64')

  See Also

  • curl_mime_encoder

method setFileData

setFileData: (filePath: string | null) => this;

• Sets the data content for this MIME part by reading from a file.

  Parameter filePath

  Path to the file, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  The file is streamed during transfer for memory efficiency. The file must be readable when the transfer starts.

  Example 1

  part
    .setName('document')
    .setFileData('/path/to/document.pdf')
    .setType('application/pdf')

  See Also

  • curl_mime_filedata

method setFileName

setFileName: (fileName: string | null) => this;

• Sets the remote filename for this part.

  Parameter filename

  The filename to send, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  This appears in the Content-Disposition header and can be different from the actual local filename when using setFileData.

  Example 1

  part
    .setName('avatar')
    .setFileData('/tmp/temp123.jpg')
    .setFileName('profile-photo.jpg')

  See Also

  • curl_mime_filename

method setHeaders

setHeaders: (headers: string[] | null) => this;

• Sets custom headers for this MIME part.

  Parameter headers

  Array of header strings, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  Each header should be in the format "Header-Name: value".

  Example 1

  part.setName('doc').setData('content').setHeaders([
    'Content-ID: <document123>',
    'X-Custom-Header: custom-value'
  ])

  See Also

  • curl_mime_headers

method setName

setName: (name: string | null) => this;

• Sets the field name for this MIME part.

  Parameter name

  The field name, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Example 1

  part.setName('username').setData('john_doe')

  See Also

  • curl_mime_name

method setSubparts

setSubparts: (mime: CurlMime | null) => this;

• Sets a MIME structure as nested subparts of this part.

  Parameter mime

  A CurlMime instance to use as subparts, or null to reset

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Remarks

  Ownership of the MIME structure transfers to this part. The subparts MIME object should not be used after this call.

  Example 1

  const subMime = new CurlMime(curl)
  subMime
    .addPart()
    .setName('nested_field')
    .setData('nested content')
  
  mime
    .addPart()
    .setName('multipart_section')
    .setSubparts(subMime)

  See Also

  • curl_mime_subparts

method setType

setType: (mimeType: string | null) => this;

• Sets the content type (MIME type) for this part.

  Parameter mimeType

  The MIME type string, or null to use default

  Returns

  this for method chaining

  Throws

  {CurlEasyError} Throws on error

  Example 1

  part
    .setName('avatar')
    .setFileData('image.png')
    .setType('image/png')

  See Also

  • curl_mime_type

constructor

constructor(message: string, code: CurlMultiCode, errorOptions?: ErrorOptions);

property code

readonly code: CurlMultiCode;

property name

static readonly name: string;

constructor

constructor(message: string, code: CurlShareCode, errorOptions?: ErrorOptions);

property code

readonly code: CurlShareCode;

property name

static readonly name: string;

property id

readonly id: number;

• This is the unique ID of the Easy handle.

  This ID is also unique across threads.

property isInsideMultiHandle

readonly isInsideMultiHandle: boolean;

• This will be true if the handle was added to a `Multi` handle.

property isMonitoringSockets

readonly isMonitoringSockets: boolean;

• This will be true if `monitorSocketEvents` was called.

property isOpen

readonly isOpen: boolean;

• This will be true if `close` was not called.

property isPausedRecv

readonly isPausedRecv: boolean;

property isPausedSend

readonly isPausedSend: boolean;

property pauseFlags

readonly pauseFlags: CurlPause;

property private

private: any;

• You can set this to anything - Use it to bind some data to this Easy instance.

  This will not be copied to other instaces created when duplicating this one.

method close

close: () => void;

• Close this handle and dispose any resources bound to it. After closed, the handle **MUST** not be used again, doing so will throw an Error.

  This is basically the same than [curl_easy_cleanup()](http://curl.haxx.se/libcurl/c/curl_easy_cleanup.html)

method debugLog

debugLog: (message: string) => void;

method dupHandle

dupHandle: () => Easy;

• Duplicate this handle with all their options and callbacks.

  Official libcurl documentation: [curl_easy_duphandle()](http://curl.haxx.se/libcurl/c/curl_easy_duphandle.html)

method getInfo

getInfo: {
    (info: 'CERTINFO'): GetInfoReturn<string[]>;
    (
        info:
            | 'HTTP_VERSION'
            | 'CAINFO'
            | 'CAPATH'
            | 'COOKIELIST'
            | 'FILETIME'
            | 'REFERER'
            | 'RTSP_CLIENT_CSEQ'
            | 'RTSP_SERVER_CSEQ'
            | 'RTSP_SESSION_ID'
            | 'ACTIVESOCKET'
            | 'APPCONNECT_TIME'
            | 'APPCONNECT_TIME_T'
            | 'CONDITION_UNMET'
            | 'CONN_ID'
            | 'CONNECT_TIME'
            | 'CONNECT_TIME_T'
            | 'CONTENT_LENGTH_DOWNLOAD'
            | 'CONTENT_LENGTH_DOWNLOAD_T'
            | 'CONTENT_LENGTH_UPLOAD'
            | 'CONTENT_LENGTH_UPLOAD_T'
            | 'CONTENT_TYPE'
            | 'EARLYDATA_SENT_T'
            | 'EFFECTIVE_METHOD'
            | 'EFFECTIVE_URL'
            | 'FILETIME_T'
            | 'FTP_ENTRY_PATH'
            | 'HEADER_SIZE'
            | 'HTTP_CONNECTCODE'
            | 'HTTPAUTH_AVAIL'
            | 'HTTPAUTH_USED'
            | 'LASTSOCKET'
            | 'LOCAL_IP'
            | 'LOCAL_PORT'
            | 'NAMELOOKUP_TIME'
            | 'NAMELOOKUP_TIME_T'
            | 'NUM_CONNECTS'
            | 'OS_ERRNO'
            | 'POSTTRANSFER_TIME_T'
            | 'PRETRANSFER_TIME'
            | 'PRETRANSFER_TIME_T'
            | 'PRIMARY_IP'
            | 'PRIMARY_PORT'
            | 'PRIVATE'
            | 'PROTOCOL'
            | 'PROXY_ERROR'
            | 'PROXY_SSL_VERIFYRESULT'
            | 'PROXYAUTH_AVAIL'
            | 'PROXYAUTH_USED'
            | 'QUEUE_TIME_T'
            | 'REDIRECT_COUNT'
            | 'REDIRECT_TIME'
            | 'REDIRECT_TIME_T'
            | 'REDIRECT_URL'
            | 'REQUEST_SIZE'
            | 'RESPONSE_CODE'
            | 'RETRY_AFTER'
            | 'RTSP_CSEQ_RECV'
            | 'SCHEME'
            | 'SIZE_DOWNLOAD'
            | 'SIZE_DOWNLOAD_T'
            | 'SIZE_UPLOAD'
            | 'SIZE_UPLOAD_T'
            | 'SPEED_DOWNLOAD'
            | 'SPEED_DOWNLOAD_T'
            | 'SPEED_UPLOAD'
            | 'SPEED_UPLOAD_T'
            | 'SSL_ENGINES'
            | 'SSL_VERIFYRESULT'
            | 'STARTTRANSFER_TIME'
            | 'STARTTRANSFER_TIME_T'
            | 'TLS_SESSION'
            | 'TLS_SSL_PTR'
            | 'TOTAL_TIME'
            | 'TOTAL_TIME_T'
            | 'USED_PROXY'
            | 'XFER_ID'
    ): GetInfoReturn<string | number>;
};