import { Buffer } from 'buffer';

declare class ZitiSocket {
    constructor(opts: any);
    /**
     *
     */
    isWebSocket: any;
    /**
     * This stream is where we'll put any data returned from a Ziti connection (see ziti_dial.data.call_back)
     */
    readableZitiStream: ReadableStream<any>;
    /**
     * The underlying Ziti Context
     * @private
     * @type {string}
     */
    private zitiContext;
    /**
     * The active HTTP request
     */
    req: any;
    /**
     * The underlying Ziti Connection
     * @private
     * @type {string}
     */
    private zitiConnection;
    /**
     *
     */
    _writable: boolean;
    /**
     *
     */
    _id: number;
    /**
     * Make a connection to the specified Ziti 'service'.  We do this by invoking the ziti_dial() function in the Ziti NodeJS-SDK.
     * @param {*} service
     */
    ziti_dial(service: any): Promise<any>;
    /**
     * Write data onto the underlying Ziti connection by invoking the ziti_write() function in the Ziti NodeJS-SDK.  The
     * NodeJS-SDK expects incoming data to be of type Buffer.
    */
    ziti_write(conn: any, buffer: any): Promise<any>;
    /**
     *
     */
    captureResponseData(conn: any, data: any): void;
    /**
     * Connect to a Ziti service.
    */
    connect(opts: any): Promise<void>;
    /**
     *
     */
    _read(): void;
    read(): void;
    /**
     *
     */
    destroy(): void;
    /**
     *
     */
    destroy(): Promise<void>;
    /**
     * Returns a Promise that will resolve _only_ after a Ziti connection has been established for this instance of ZitiSocket.
     */
    getZitiConnection(): Promise<any>;
    connAsHex(conn: any): string;
    /**
     * Implements the writeable stream method `_write` by pushing the data onto the underlying Ziti connection.
     * It is possible that this function is called before the Ziti connect has completed, so this function will (currently)
     * await Ziti connection establishment (as opposed to buffering the data).
    */
    write(chunk: any, encoding: any, cb: any): Promise<void>;
    /**
     *
     */
    cork(): void;
    uncork(): void;
    /**
     *
     */
    pause(): void;
    resume(): void;
    /**
     *
     */
    end(data: any, encoding: any, callback: any): Promise<void>;
    /**
     * Implements the writeable stream method `_final` used when .end() is called to write the final data to the stream.
     */
    _final(cb: any): void;
    /**
     *
     */
    setTimeout(): void;
    /**
     *
     */
    setNoDelay(): void;
    /**
     *
     */
    unshift(head: any): void;
    get writable(): any;
}

/**
 * Base HTTP "ZitiAgent" class.
 *
 */
declare class ZitiAgent {
    constructor(options: any);
    options: any;
    proxy: any;
    secure: boolean;
    defaultPort: number;
    /**
     *
     */
    end(): void;
    /**
     * Creates and returns a `ZitiSocket` instance to use for an HTTP request. If
     * the serviceScheme is 'https', then the socket will also embed a `ZitiInnerTLSSocket`
     * instance to facilitate TLS traffic over/within the outer mTLS socket.
     *
     * @api public
     */
    createConnection(opts: any, deferredFn: any): Promise<void>;
    deferredFn: any;
    socket: ZitiSocket;
}

declare class ZitiAgentPool {
    constructor(options: any);
    options: any;
    logger: any;
    ZitiAgent: typeof ZitiAgent;
    Promise: any;
    _zitiAgents: any[];
    _idle: any[];
    _expired: WeakSet<object>;
    _pendingQueue: any[];
    _endCallback: any;
    ending: boolean;
    ended: boolean;
    _hasFive(): boolean;
    _isFull(): boolean;
    _pulseQueue(): Promise<void>;
    _remove(zitiAgent: any): void;
    connect(req: any, reqOptions: any, cb: any): Promise<any>;
    newZitiAgent(pendingItem: any): Promise<void>;
    _acquireZitiAgent(zitiAgent: any, pendingItem: any, idleListener: any, isNew: any): void;
    _releaseOnce(zitiAgent: any, idleListener: any): (err: any) => void;
    _release(zitiAgent: any, idleListener: any, err: any): void;
    query(text: any, values: any, cb: any): any;
    end(cb: any): any;
    get waitingCount(): number;
    get idleCount(): number;
    get expiredCount(): any;
    get totalCount(): number;
}

/**
 *    ZitiEnroller
 */
declare class ZitiEnroller {
    /**
     *
     */
    constructor(options: any);
    _zitiContext: any;
    logger: any;
    /**
     *
     */
    initialize(): Promise<void>;
    /**
     *
     */
    enroll(): Promise<boolean>;
    /**
     *
     */
    generateCSR(wasmInstance: any): Promise<void>;
    _csr: any;
    /**
     *
     */
    createEphemeralCert(): Promise<boolean>;
    _cas: any;
    _cert: any;
    _certExpiryTime: any;
    printEphemeralCert(): Promise<void>;
    /**
     *
     */
    get casPEM(): any;
    /**
     *
     */
    get certPEM(): any;
    /**
     *
     */
    get certPEMExpiryTime(): any;
}

/**
 *    Messages
 */
declare class Messages {
    /**
     *
     */
    constructor(options: any);
    _items: Map<any, any>;
    _zitiContext: any;
    _conn: any;
    _channel: any;
    /**
     * Creates new message and stores it in the list.
     *
     * @param {String|Number} messageId
     * @param {Function} fn
     * @param {Number} timeout
     * @returns {Promise}
     */
    create(conn: any, messageId: string | number, fn: Function, timeout: number): Promise<any>;
    resolve(conn: any, data: any): void;
    rejectAll(error: any): void;
    _rejectExistingMessage(messageId: any): void;
    _getNativePromise(): any;
    _createNewMessage(conn: any, messageId: any, fn: any, timeout: any): any;
    _deleteMessage(messageId: any, message: any): void;
}

/**
 *    ZitiConnection
 */
declare class ZitiConnection {
    /**
     *
     */
    constructor(options: any);
    _zitiContext: any;
    _data: any;
    _state: number;
    _timeout: any;
    _edgeMsgSeq: number;
    _id: any;
    _messages: Messages;
    get zitiContext(): any;
    get data(): any;
    get messages(): Messages;
    set state(state: number);
    get state(): number;
    get id(): any;
    get appData(): any;
    getAndIncrementSequence(): number;
    set socket(socket: any);
    get socket(): any;
    _socket: any;
    set dataCallback(fn: any);
    get dataCallback(): any;
    _dataCallback: any;
    set channel(channel: any);
    get channel(): any;
    _channel: any;
    set encrypted(encrypted: any);
    get encrypted(): any;
    _encrypted: any;
    set cryptoEstablishComplete(complete: any);
    get cryptoEstablishComplete(): any;
    _cryptoEstablishComplete: any;
    set keypair(keypair: any);
    get keypair(): any;
    _keypair: any;
    set sharedRx(sharedRx: any);
    get sharedRx(): any;
    _sharedRx: any;
    set sharedTx(sharedTx: any);
    get sharedTx(): any;
    _sharedTx: any;
    set crypt_o(crypt_o: any);
    get crypt_o(): any;
    _crypt_o: any;
    set crypt_i(crypt_i: any);
    get crypt_i(): any;
    _crypt_i: any;
    set networkSessionToken(networkSessionToken: any);
    get networkSessionToken(): any;
    _networkSessionToken: any;
}

/**
 * ZitiWebSocketWrapperCtor:
 *
 */
declare class ZitiWebSocketWrapperCtor {
    /**
     * Create a new `ZitiWebSocketWrapper`.
     *
     */
    constructor(address: any, protocols: any, options: any);
}

/**
 *    ZitiContext
 */
declare class ZitiContext {
    /**
     *
     */
    constructor(options: any);
    _initialized: boolean;
    _initializedInnerWASM: boolean;
    _keyType: any;
    logger: any;
    controllerApi: any;
    updbUser: any;
    updbPswd: any;
    token_type: any;
    id_token: any;
    access_token: any;
    sdkType: any;
    sdkVersion: any;
    sdkBranch: any;
    sdkRevision: any;
    apiSessionHeartbeatTimeMin: any;
    apiSessionHeartbeatTimeMax: any;
    bootstrapperTargetService: any;
    bootstrapperHost: any;
    proxydomain: string;
    _libCrypto: any;
    _libCryptoInitialized: boolean;
    _network_sessions: Map<any, any>;
    _services: Map<any, any>;
    _channels: Map<any, any>;
    _channelsById: Map<any, any>;
    _wasmFDsById: Map<any, any>;
    /**
     * We start the channel id's at 10 so that they will be well above any 'fd'
     * used by traditional WebAssembly (i.e. stdin, stdout, stderr). In the WebAssembly
     * we have logic that watches for read/write operations to 'fd' values, and
     * any that target a 'fd' above 10 will route the i/o to the appropriate ZitiChannel|ZitiTLSSocket.
     */
    _channelSeq: number;
    _wasmFDSeq: number;
    _connSeq: number;
    _ensureAPISessionMutex: any;
    _getNetworkSessionByServiceIdMutex: any;
    _getServiceNameByHostNameAndPortMutex: any;
    _isCertExpiredMutex: any;
    _connectMutexWithTimeout: any;
    _tlsHandshakeLock: any;
    _fetchSemaphoreHTTP: any;
    _fetchSemaphoreHTTPS: any;
    _pkey: any;
    _privateKeyPEM: any;
    _publicKeyPEM: any;
    _casPEM: any;
    _certPEM: any;
    _apiSession: any;
    _timeout: number;
    _didInitialGetPendingChannelConnects: boolean;
    _agentPool: ZitiAgentPool;
    controllerCapabilities: any[];
    controllerCapabilitiesOIDCErrorEncountered: boolean;
    get libCrypto(): any;
    get timeout(): number;
    setKeyTypeEC(): void;
    setKeyTypeRSA(): void;
    /**
     *
     */
    initialize(options: any): Promise<void>;
    _zitiBrowzerEdgeClient: any;
    targetService: any;
    targetServiceAppData: {
        dst_protocol: undefined;
        dst_port: any;
    };
    targetServiceHost: string;
    targetServiceHostAndPort: string;
    _zitiEnroller: ZitiEnroller;
    /**
     *
     */
    sdk_initialize_loadWASM(options: any): Promise<void>;
    /**
     *
     * @param {*} access_token
     */
    setAccessToken(access_token: any): boolean;
    createEnroller(): void;
    printEphemeralCert(): Promise<void>;
    generateKeyPair(): Promise<any>;
    /**
     * Remain in lazy-sleepy loop until context is initialized.
     *
     * @param {*} ctx
     */
    awaitInitializationComplete(): Promise<any>;
    /**
     * Remain in lazy-sleepy loop until we have the access token.
     *
     * @param {*} ctx
     */
    awaitAccessTokenPresent(): Promise<any>;
    /**
     *
     */
    getZitiAgentPool(): ZitiAgentPool;
    /**
     *
     */
    getWASMInstance(): Promise<any>;
    /**
     *
     */
    reInitialize(options: any): Promise<void>;
    /**
     *
     * @param {*} options
     * @returns ZitiContext
     */
    createZitiBrowzerEdgeClient(options: any): any;
    /**
     *
     */
    generateRSAKey(): any;
    /**
     *
     */
    generateECKey(): Promise<any>;
    /**
     *
     */
    getPrivateKeyPEM(pkey: any): any;
    /**
     *
     */
    getPublicKeyPEM(pkey: any): any;
    /**
     *
     */
    createCertificateSigningRequest(wasmInstance: any, { key, curve, compressed, version, name, }: {
        key?: any;
        curve?: any;
        compressed?: any;
        version?: number;
        name?: string;
    }): any;
    _csrPEM: any;
    /**
     *
     */
    get_rsaKey(): Promise<any>;
    /**
     *
     */
    get_ecKey(): Promise<any>;
    /**
     *
     */
    get_pKey(): Promise<any>;
    /**
     *
     */
    get_privateKeyPEM(): Promise<any>;
    /**
     *
     */
    get_publicKeyPEM(): Promise<any>;
    /**
     *
     * @returns
     */
    ssl_CTX_new(wasmInstance: any): Promise<any>;
    /**
     *
     * @returns
     */
    ssl_CTX_add_private_key(wasmInstance: any, sslContext: any): Promise<any>;
    /**
     *
     * @returns
     */
    ssl_CTX_add_certificate(wasmInstance: any, sslContext: any): Promise<any>;
    /**
     *
     * @returns
     */
    ssl_CTX_verify_certificate_and_key(wasmInstance: any, sslContext: any): any;
    /**
     *
     */
    bio_new_ssl_connect(wasmInstance: any, sslContext: any): any;
    /**
     *
     */
    bio_get_ssl(wasmInstance: any, bio: any): any;
    /**
     *
     */
    ssl_do_handshake(useLock: any, fd: any, wasmInstance: any, ssl: any): Promise<any>;
    ssl_is_init_finished(wasmInstance: any, ssl: any): any;
    /**
     *
     * @returns
     */
    ssl_set_fd(wasmInstance: any, ssl: any, fd: any): any;
    /**
     *
     */
    acquireTLSHandshakeLock(fd: any): Promise<void>;
    _tlsHandshakeLockRelease: any;
    _tlsHandshakeLockFD: any;
    releaseTLSHandshakeLock(fd: any): void;
    /**
     *
     * @param {*} wasmFD      // id of socket
     * @param {*} arrayBuffer // ArrayBuffer
     */
    tls_enqueue(wasmInstance: any, wasmFD: any, arrayBuffer: any): Promise<void>;
    /**
     *
     * @param {*} wasmFD      // id of socket
     */
    peekTLSData(wasmInstance: any, wasmFD: any): any;
    /**
     *
     */
    tls_write(wasmInstance: any, ssl: any, wireData: any): Promise<any>;
    /**
     *
     */
    tls_read(wasmInstance: any, ssl: any): Promise<any>;
    serializeQueryParams(parameters: any): string;
    /**
     *  do_oidc_authorize
     *
     *  Utilize Controller's HA OIDC endpoint to acquire an authID.
     *  This code exists here, inline, instead of being in the zitiBrowzerEdgeClient, because the controller's
     *  swagger spec doesn't include the new HA OIDC endpoint refs.
     */
    do_oidc_authorize(codeChallange: any): any;
    /**
     *  do_oidc_login_ext_jwt
     *
     *  Utilize Controller's HA OIDC endpoint to authenticate.
     *  This code exists here, inline, instead of being in the zitiBrowzerEdgeClient, because the controller's
     *  swagger spec doesn't include the new HA OIDC endpoint refs.
     */
    do_oidc_login_ext_jwt(parameters: any): Promise<any>;
    /**
     *  do_oidc_authorize_callback
     *
     *  Utilize Controller's HA OIDC endpoint to authenticate.
     *  This code exists here, inline, instead of being in the zitiBrowzerEdgeClient, because the controller's
     *  swagger spec doesn't include the new HA OIDC endpoint refs.
     */
    do_oidc_authorize_callback(parameters: any): Promise<any>;
    /**
     *  do_oidc_oauth_token
     *
     *  Utilize Controller's HA OIDC endpoint to acquire an apiToken.
     *  This code exists here, inline, instead of being in the zitiBrowzerEdgeClient, because the controller's
     *  swagger spec doesn't include the new HA OIDC endpoint refs.
     */
    do_oidc_oauth_token(parameters: any): Promise<any>;
    /**
     *  do_oidc_token_refresh
     *
     *  Utilize Controller's HA OIDC endpoint to acquire a refreshed apiToken.
     *  This code exists here, inline, instead of being in the zitiBrowzerEdgeClient, because the controller's
     *  swagger spec doesn't include the new HA OIDC endpoint refs.
     */
    do_oidc_token_refresh(): Promise<any>;
    /**
     *
     */
    doAuthenticate(token: any): any;
    delay(time: any): Promise<any>;
    /**
     *
     */
    getAccessTokenEmail(): Promise<any>;
    /**
     *
     */
    isControllerHA(): boolean;
    /**
     *
     */
    getFreshAPISessionWithToken(token: any): Promise<boolean>;
    /**
     *
     */
    getCurrentAPISession(): any;
    /**
     *
     */
    setCurrentAPISession(apiSession: any): void;
    /**
     *
     */
    getFreshAPISession(): Promise<any>;
    /**
     *
     */
    ensureAPISession(): Promise<undefined>;
    /**
     *
     */
    enroll(): Promise<boolean>;
    _certExpiryTime: any;
    _certPEMLeaf: any;
    _certPEMIntermediatesArray: any;
    /**
     *
     */
    getCasPEM(): Promise<any>;
    /**
     *
     */
    getCertPEM(): Promise<any>;
    /**
     *
     */
    getCertPEMLeaf(): Promise<any>;
    /**
     *
     */
    getCertPEMIntermediatesArray(): Promise<any>;
    /**
     *
     */
    getCertPEMExpiryTime(): Promise<any>;
    /**
     *
     */
    apiSessionHeartbeat(self: any): Promise<void>;
    /**
     *
     */
    getApiSessionHeartbeatTime(): number;
    /**
     * Returns a random integer between min (inclusive) and max (inclusive).
     */
    getRandomInt(min: any, max: any): any;
    /**
     *
     */
    fetchServices(): Promise<Map<any, any>>;
    /**
     *
     */
    listControllerVersion(): Promise<any>;
    _controllerVersion: any;
    get controllerVersion(): any;
    /**
     *
     */
    listExternalJwtSigners(): Promise<any>;
    _externalJwtSigners: any;
    /**
     *
     */
    getExternalJwtSignerScopesByClientId(clientId: any): any;
    get services(): Map<any, any>;
    /**
     *
     */
    getServiceIdByName(name: any): any;
    /**
     *
     */
    getServiceEncryptionRequiredByName(name: any): any;
    /**
     *
     */
    getServiceConfigByName(name: any): Promise<any>;
    /**
     *
     */
    getConfigHostByServiceName(name: any): Promise<string>;
    /**
     *
     */
    getServiceNameByConfigHost(hostname: any): Promise<any>;
    /**
     *  If scheme is 'https' then look for port 443. If 443 not found,
     *    use portRange.low
     *
     *  If scheme is 'http'  then look for any port that is NOT 443
     */
    getPortByScheme(portRanges: any, scheme: any): any;
    getProtocol(protocolsArray: any): undefined;
    /**
     *
     */
    getConnectAppDataByServiceName(name: any, scheme: any): Promise<{
        dst_protocol: undefined;
        dst_port: any;
    }>;
    /**
     *
     */
    getConfigHostAndPortByServiceName(name: any): Promise<{
        host: any;
        port: any;
    }>;
    /**
     *
     */
    getNetworkSessionByServiceId(serviceID: any): Promise<any>;
    memoized_getNetworkSessionByServiceId: any;
    /**
     *
     */
    createNetworkSession(id: any): Promise<any>;
    /**
     * Allocate a new Connection.
     *
     * @param {*} data
     * @return {ZitiConnection}
     */
    newConnection(data: any): ZitiConnection;
    _getNativePromise(): any;
    /**
     * Dial the `service`.
     *
     * @param {ZitiConnection} conn
     * @param {String} service
     */
    dial(conn: ZitiConnection, service: string): Promise<any>;
    getEdgeRouterURL(edgeRouter: any): any;
    /**
     * Connect specified ZitiConnection to the nearest Edge Router.
     *
     * @param {Array} edgeRouters
     */
    _getPendingChannelConnects(conn: any, edgeRouters: any[]): Promise<any[]>;
    /**
     * Remain in lazy-sleepy loop until specified channel is connected.
     *
     * @param {*} channel
     */
    awaitChannelConnectComplete(ch: any): Promise<any>;
    getChannelByEdgeRouter(conn: any, edgeRouter: any): Promise<undefined>;
    /**
     *
     */
    addWASMFD(socket: any): any;
    /**
     *
     */
    findChannelByEdgeRouter(edgeRouter: any): {};
    activeChannelCount(): number;
    /**
     *
     */
    updateChannelsWithUpdatedToken(apiSessionToken: any): void;
    /**
     * Connect specified ZitiConnection to the nearest Edge Router.
     *
     * @param {ZitiConnection} conn
     * @param {*} networkSession
     */
    connect(conn: ZitiConnection, networkSession: any): Promise<void>;
    /**
     * Determine if the given URL should be routed over Ziti.
     *
     * @param {*} url
     */
    shouldRouteOverZiti(url: any): Promise<any>;
    memoized_shouldRouteOverZiti: any;
    shouldRouteOverZitiSync(url: any): any;
    /**
     * Determine if the given URL should be handled via CORS Proxy.
     *
     */
    shouldRouteOverCORSProxy(url: any): boolean;
    /**
     *
     * @param {*} hostname
     * @param {*} port
     * @returns
     */
    getServiceNameByHostName(hostname: any): Promise<any>;
    memoized_getServiceNameByHostName: any;
    /**
     *
     * @param {*} hostname
     * @param {*} port
     * @returns
     */
    getServiceNameByHostNameAndPort(hostname: any, port: any): Promise<any>;
    memoized_getServiceNameByHostNameAndPort: any;
    /**
     "config": {
       "ziti-tunneler-client.v1": {
           "ziti-tunneler-client.v1": {
             "hostname": "example.com",
            "port": 443
          }
        }
      }
    */
    _getMatchConfigTunnelerClientV1: (config: any, hostname: any, port: any) => boolean;
    /**
      "config": {
        "intercept.v1": {
          "addresses": ["example.com"],
          "portRanges": [{
            "high": 443,
            "low": 443
          }],
          "protocols": ["tcp"]
        }
      }
    */
    _getMatchConfigInterceptV1: (config: any, hostname: any, port: any) => boolean;
    /**
     *
     */
    isCertExpired(): Promise<void>;
    /**
     *
     */
    flushExpiredAPISessionData(): void;
    /**
     *
     */
    getNextConnectionId(): number;
    /**
     *
     */
    getNextChannelId(): number;
    /**
     *
     */
    getNextWASMFDId(): number;
    closeChannelByEdgeRouter(edgeRouter: any): void;
    closeAllChannels(): void;
    get zitiWebSocketWrapper(): typeof ZitiWebSocketWrapperCtor;
    /**
     * Close specified ZitiConnection with Edge Router.
     *
     * @param {ZitiConnection} conn
     */
    close(conn: ZitiConnection): Promise<void>;
    /**
     *
     */
    truncateString(str: any, num: any): any;
    /**
     *
     * @param {*} options
     * @returns Response
     */
    httpFetch(url: any, opts: any): Promise<any>;
}

/**
 *
 */
declare class ZitiBrowzerCore {
    /**
     *
     */
    constructor(options?: {});
    /**
     *
     */
    createZitiContext(options: any): ZitiContext;
    _zitiContext: ZitiContext;
    /**
     *
     * @param {*} defaults
     * @returns ZitiContext
     */
    createZitiContextWithDefaults(defaults: any): any;
    get context(): ZitiContext;
    /**
     *
     * @param {*} options
     * @returns ZitiLogger
     */
    createZitiLogger(options: any): any;
    _zitiLogger: any;
    /**
     *
     * @returns ZitiLogger
     */
    createZitiLoggerWithDefaults(): any;
    get logger(): any;
}

/**
 * Initialize a new `HttpHeaders`.
 *
 * @param   Object  headers  Response headers
 * @api public
 */
declare function HttpHeaders(init?: any): any;
declare class HttpHeaders {
    /**
     * Initialize a new `HttpHeaders`.
     *
     * @param   Object  headers  Response headers
     * @api public
     */
    constructor(init?: any);
    /**
     * Return combined header value given name
     *
     * @param   String  name  Header name
     * @return  Mixed
     */
    get(name: any): any;
    /**
     * Iterate over all headers
     *
     * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
     * @param   Boolean   thisArg   `this` context for callback function
     * @return  Void
     */
    forEach(callback: any, thisArg?: any): void;
    /**
     * Overwrite header values given name
     *
     * @param   String  name   Header name
     * @param   String  value  Header value
     * @return  Void
     */
    set(name: any, value: any): void;
    /**
     * Append a value onto existing header
     *
     * @param   String  name   Header name
     * @param   String  value  Header value
     * @return  Void
     */
    append(name: any, value: any): void;
    /**
     * Check for header name existence
     *
     * @param   String   name  Header name
     * @return  Boolean
     */
    has(name: any): boolean;
    /**
     * Delete all header values given name
     *
     * @param   String  name  Header name
     * @return  Void
     */
    delete(name: any): void;
    /**
     * Return raw headers (non-spec api)
     *
     * @return  Object
     */
    raw(): any;
    /**
     * Get an iterator on keys.
     *
     * @return  Iterator
     */
    keys(): any;
    /**
     * Get an iterator on values.
     *
     * @return  Iterator
     */
    values(): any;
    /**
     * Get an iterator on entries.
     *
     * This is the default iterator of the HttpHeaders object.
     *
     * @return  Iterator
     */
    entries(): any;
    /**
     * Create a HttpHeaders object from an object of headers, ignoring those that do
     * not conform to HTTP grammar productions.
     *
     * @param   Object  obj  Object of headers
     * @return  HttpHeaders
     */
    createHeadersLenient(obj: any): HttpHeaders;
    getAllHeaders(): any[];
    [MAP]: any;
}
declare const MAP: unique symbol;

/**
 * Initialize a new `ZitiHttpRequest`.
 *
 * @api public
 */
declare function ZitiHttpRequest(serviceNameOrConn: any, input: any, init: {}, zitiContext: any): any;
declare class ZitiHttpRequest {
    /**
     * Initialize a new `ZitiHttpRequest`.
     *
     * @api public
     */
    constructor(serviceNameOrConn: any, input: any, init: {}, zitiContext: any);
    getZitiContext(): any;
    getServiceName(): string;
    getServiceScheme(): any;
    getServiceConnectAppData(): any;
    getConn(): any;
    getMethod(): any;
    getHeaders(): HttpHeaders;
    getRedirect(): any;
    getParsedURL(): URL;
    getRequestOptions(): Promise<{
        zitiContext: any;
        serviceName: string;
        serviceScheme: any;
        serviceConnectAppData: any;
        conn: any;
        method: any;
        headers: HttpHeaders;
        body: any;
    }>;
    [INTERNALS$1]: {
        serviceName: string;
        serviceScheme: any;
        serviceConnectAppData: any;
        conn: any;
        method: any;
        redirect: any;
        headers: HttpHeaders;
        parsedURL: URL;
        zitiContext: any;
    };
}

declare const INTERNALS$1: unique symbol;

/**
 * Initialize a new `HttpResponse`.
 *
 * @api public
 */
declare function HttpResponse(body?: any, opts?: {}): any;
declare class HttpResponse {
    /**
     * Initialize a new `HttpResponse`.
     *
     * @api public
     */
    constructor(body?: any, opts?: {});
    [INTERNALS]: {
        url: any;
        status: any;
        headers: HttpHeaders;
        counter: any;
    };
}
declare const INTERNALS: unique symbol;

/**
 * Create readable "multipart/form-data" streams.
 * Can be used to submit forms
 * and file uploads to other web applications.
 *
 * @constructor
 * @param {Object} options - Properties to be added/overriden for ZitiFormData and CombinedStream
 */
declare function ZitiFormData(options: any): ZitiFormData;
declare class ZitiFormData {
    /**
     * Create readable "multipart/form-data" streams.
     * Can be used to submit forms
     * and file uploads to other web applications.
     *
     * @constructor
     * @param {Object} options - Properties to be added/overriden for ZitiFormData and CombinedStream
     */
    constructor(options: any);
    _overheadLength: number;
    _valueLength: number;
    _valuesToMeasure: any[];
    _streams: any[];
    append(field: any, value: any, options: any): void;
    _trackLength(header: any, value: any, options: any): void;
    _lengthRetriever(value: any, callback: any): void;
    _multiPartHeader(field: any, value: any, options: any): any;
    _getContentDisposition(value: any, options: any): string;
    _getContentType(value: any, options: any): any;
    _multiPartFooter(): any;
    _lastBoundary(): string;
    getHeaders(userHeaders: any): {
        'content-type': string;
    };
    setBoundary(boundary: any): void;
    _boundary: any;
    getBoundary(): any;
    getStream(): any;
    getBuffer(): Promise<any>;
    _generateBoundary(): void;
    getLengthSync(): number;
    hasKnownLength(): boolean;
    getLength(cb: any): void;
    _error(err: any): void;
    error: any;
    toString(): string;
}
declare namespace ZitiFormData {
    let LINE_BREAK: string;
    let DEFAULT_CONTENT_TYPE: string;
}

declare class BrowserStdout {
    constructor(opts: any);
    req: any;
    _write(chunk: any, encoding: any, cb: any): void;
    write(chunk: any, encoding: any, cb: any): void;
    end(): void;
}

declare function ClientRequest(input: any, options: any, cb: any): void;
declare class ClientRequest {
    constructor(input: any, options: any, cb: any);
    socketPath: any;
    method: any;
    maxHeaderSize: any;
    path: any;
    domProxyHit: any;
    useChunkedEncodingByDefault: boolean;
    _ended: boolean;
    res: any;
    aborted: boolean;
    timeoutCb: any;
    upgradeOrConnect: boolean;
    parser: any;
    maxHeadersCount: any;
    reusedSocket: boolean;
    host: any;
    protocol: string;
    _last: boolean;
    shouldKeepAlive: boolean;
    _finish(): void;
    _implicitHeader(): void;
    abort(): void;
    destroy(err: any): this;
    destroyed: boolean;
    onSocket(socket: any, err: any): void;
    _deferToConnect: typeof _deferToConnect;
    setTimeout(msecs: any, callback: any): this;
    setNoDelay(noDelay: any): void;
    setSocketKeepAlive(enable: any, initialDelay: any): void;
    clearTimeout(cb: any): void;
    [kError]: any;
}
declare function _deferToConnect(method: any, arguments_: any, cb: any): void;
declare const kError: unique symbol;

declare class BufferList {
    constructor(options: any);
    head: any;
    tail: any;
    length: number;
    push(v: any): void;
    unshift(v: any): void;
    shift(): any;
    clear(): void;
    join(s: any): string;
    /**
     * @type    {Buffer}
     * @return  {Buffer}
     */
    concat(n: any): Buffer;
    consume(n: any, hasStrings: any): any;
    first(): any;
    _getString(n: any): any;
    /**
     * @type    {Buffer}
     * @return  {Buffer}
     */
    _getBuffer(n: any): Buffer;
    value(_: any, options: any): any;
}

/**
 * @extends {Stream}
 */
declare class Readable {
    constructor(options: any);
    _readableState: ReadableState;
    readable: boolean;
    _read(n: any): void;
    _destroy(err: any, cb: any): void;
    set destroyed(value: any);
    get destroyed(): any;
    destroy: any;
    _undestroy: any;
    push(chunk: any, encoding: any): boolean;
    unshift(chunk: any): boolean;
    readableAddChunk(stream: any, chunk: any, encoding: any, addToFront: any, skipChunkCheck: any): boolean;
    isPaused(): boolean;
    setEncoding(enc: any): this;
    read(n: any): any;
    pipe(dest: any, pipeOpts: any): any;
    unpipe(dest: any): this;
    on(ev: any, fn: any): any;
    addListener: (ev: any, fn: any) => any;
    removeListener(ev: any, fn: any): any;
    removeAllListeners(ev: any): any;
    resume(): this;
    pause(): this;
    wrap(stream: any): this;
    get readableHighWaterMark(): any;
    get readableBuffer(): any;
    set readableFlowing(state: any);
    get readableFlowing(): any;
    get readableLength(): any;
    ReadableState: typeof ReadableState;
}

declare function ReadableState(options: any, stream: any, isDuplex: any): void;
declare class ReadableState {
    constructor(options: any, stream: any, isDuplex: any);
    objectMode: boolean;
    highWaterMark: number;
    buffer: BufferList;
    length: number;
    pipes: any;
    pipesCount: number;
    flowing: any;
    ended: boolean;
    endEmitted: boolean;
    reading: boolean;
    sync: boolean;
    needReadable: boolean;
    emittedReadable: boolean;
    readableListening: boolean;
    resumeScheduled: boolean;
    paused: boolean;
    emitClose: boolean;
    autoDestroy: boolean;
    destroyed: boolean;
    defaultEncoding: any;
    awaitDrain: number;
    readingMore: boolean;
    decoder: any;
    encoding: any;
}

declare class IncomingMessage extends Readable {
    socket: any;
    httpVersionMajor: any;
    httpVersionMinor: any;
    httpVersion: any;
    complete: boolean;
    headers: {};
    rawHeaders: any[];
    trailers: {};
    rawTrailers: any[];
    aborted: boolean;
    upgrade: any;
    url: string;
    method: any;
    statusCode: any;
    statusMessage: any;
    client: any;
    _consuming: boolean;
    _dumped: boolean;
    set connection(val: any);
    get connection(): any;
    setTimeout(msecs: any, callback: any): this;
    _addHeaderLines(headers: any, n: any): void;
    _addHeaderLine(field: any, value: any, dest: any): void;
    _dump(): void;
}

declare function validateHeaderName(name: any): void;
declare function validateHeaderValue(name: any, value: any): void;
declare function OutgoingMessage(): void;
declare class OutgoingMessage {
    outputData: any[];
    outputSize: number;
    writable: boolean;
    destroyed: boolean;
    _last: boolean;
    chunkedEncoding: boolean;
    shouldKeepAlive: boolean;
    useChunkedEncodingByDefault: boolean;
    sendDate: boolean;
    _removedConnection: boolean;
    _removedContLen: boolean;
    _removedTE: boolean;
    _contentLength: number;
    _hasBody: boolean;
    _trailer: string;
    finished: boolean;
    _headerSent: boolean;
    _closed: boolean;
    socket: any;
    _header: any;
    _keepAliveTimeout: number;
    _onPendingData: typeof noopPendingOutput;
    get writableFinished(): boolean;
    get writableObjectMode(): boolean;
    get writableLength(): any;
    get writableHighWaterMark(): any;
    get writableCorked(): any;
    set connection(value: any);
    get connection(): any;
    _renderHeaders(): {};
    cork(): void;
    uncork(): void;
    setTimeout(msecs: any, callback: any): this;
    destroy(error: any): this;
    _send(data: any, encoding: any, callback: any): any;
    _writeRaw: typeof _writeRaw;
    _storeHeader: typeof _storeHeader;
    setHeader(name: any, value: any): void;
    getHeader(name: any): any;
    getHeaderNames(): string[];
    getHeaders(): any;
    hasHeader(name: any): boolean;
    removeHeader(name: any): void;
    _implicitHeader(): never;
    get headersSent(): boolean;
    get writableEnded(): boolean;
    write(chunk: any, encoding: any, callback: any): any;
    addTrailers(headers: any): void;
    end(chunk: any, encoding: any, callback: any): this;
    _finish(): void;
    _flush(): void;
    _flushOutput(socket: any): any;
    flushHeaders(): void;
    pipe(): void;
    [kCorked]: number;
}
declare function noopPendingOutput(amount: any): void;
declare function _writeRaw(data: any, encoding: any, callback: any): any;
declare function _storeHeader(firstLine: any, headers: any): void;
declare class _storeHeader {
    constructor(firstLine: any, headers: any);
    chunkedEncoding: boolean;
    shouldKeepAlive: boolean;
    _last: boolean;
    _header: string;
    _headerSent: boolean;
}
declare const kCorked: unique symbol;

declare namespace http {
    export let METHODS: string[];
    export { ClientRequest };
    export { IncomingMessage };
    export { OutgoingMessage };
    export { validateHeaderName };
    export { validateHeaderValue };
    export { get };
    export { request };
}

declare function get(url: any, options: any, cb: any): ClientRequest;
declare function request(url: any, options: any, cb: any): ClientRequest;

declare namespace ZITI_CONSTANTS {
    let ZITI_JWT: string;
    let ZITI_CONTROLLER: string;
    let ZITI_CONTROLLER_WS: string;
    let ZITI_EXPIRY_TIME: string;
    let ZITI_IDENTITY_CERT: string;
    let ZITI_IDENTITY_PUBLIC_KEY_FILENAME: string;
    let ZITI_IDENTITY_PRIVATE_KEY_FILENAME: string;
    let ZITI_IDENTITY_PUBLIC_KEY_FILE_NOT_FOUND: string;
    let ZITI_IDENTITY_PRIVATE_KEY_FILE_NOT_FOUND: string;
    let ZITI_IDENTITY_KEYPAIR_FOUND: string;
    let ZITI_IDENTITY_KEYPAIR_OBTAIN_FROM_FS: string;
    let ZITI_IDENTITY_KEYPAIR_OBTAIN_FROM_IDB: string;
    let ZITI_IDENTITY_PUBLIC_KEY: string;
    let ZITI_IDENTITY_PRIVATE_KEY: string;
    let ZITI_IDENTITY_CA: string;
    let ZITI_SERVICES: string;
    let ZITI_API_SESSION_TOKEN: string;
    let ZITI_IDENTITY_USERNAME: string;
    let ZITI_IDENTITY_PASSWORD: string;
    let ZITI_NETWORK_SESSIONS: string;
    let ZITI_DEFAULT_TIMEOUT: number;
    let ZITI_EVENT_XGRESS: string;
    let ZITI_EVENT_XGRESS_TX: string;
    let ZITI_EVENT_XGRESS_RX: string;
    let ZITI_EVENT_INVALID_AUTH: string;
    let ZITI_EVENT_NO_SERVICE: string;
    let ZITI_EVENT_NO_CONFIG_FOR_SERVICE: string;
    let ZITI_EVENT_NO_CONFIG_FOR_HOSTNAME: string;
    let ZITI_EVENT_SESSION_CREATION_ERROR: string;
    let ZITI_EVENT_NO_WSS_ROUTERS: string;
    let ZITI_EVENT_IDP_AUTH_HEALTH: string;
    let ZITI_EVENT_CHANNEL_CONNECT_FAIL: string;
    let ZITI_EVENT_NESTED_TLS_HANDSHAKE_TIMEOUT: string;
    let ZITI_EVENT_NO_CONFIG_PROTOCOL_FOR_SERVICE: string;
    let ZITI_EVENT_WSS_ROUTER_CONNECTION_ERROR: string;
    let ZITI_EVENT_CONTROLLER_CONNECTION_ERROR: string;
    let ZITI_EVENT_DEPRECATION_ID_TOKEN: string;
    let ZITI_EVENT_ACCESS_TOKEN_REFRESHED: string;
    let ZITI_EVENT_XGRESS_RX_NESTED_TLS: string;
    let ZITI_HA_CONTROLLER: string;
    let ZITI_OIDC_AUTH: string;
    let ZITI_BOOTSTRAPPER_CONTROLLER_PROXY_PATH: string;
}

export { BrowserStdout, HttpResponse, ZITI_CONSTANTS, ZitiBrowzerCore, ZitiFormData, ZitiHttpRequest, http };