@wopee-io/wopee.wdio 5.1.0 → 5.2.5

package/node_modules/@autonomous-testing/sdk/build/infrastructure/adapters/apolloAdapter/errors.d.ts

@@ -0,0 +1,20 @@
+import { WopeeError } from '../../../shared';
+import { ZodError } from 'zod';
+/**
+ * Turns a zod validation failure into readable prose. Fields without a hint fall
+ * back to the bare zod message, so every config failure reads as a sentence
+ * rather than a ZodError dump.
+ */
+export declare function toConfigError(error: ZodError): WopeeError;
+/**
+ * Wraps a failed API call in a `WopeeError` that says what to do about it.
+ *
+ * The discriminator for "unreachable" is the absence of a response rather than
+ * an errno allowlist — that covers DNS, TCP, TLS and proxy-tunnel failures
+ * without going stale.
+ */
+export declare function toApiRequestError(error: unknown, context: {
+    apiUrl: string;
+    projectUuid?: string;
+}): WopeeError;
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@autonomous-testing/sdk/build/infrastructure/adapters/apolloAdapter/errors.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toConfigError = toConfigError;
+exports.toApiRequestError = toApiRequestError;
+const shared_1 = require("../../../shared");
+const axios_config_1 = require("./axios-config");
+const axios_1 = __importDefault(require("axios"));
+const DOCS_URL = 'https://docs.wopee.io/';
+const CMD_URL = 'https://cmd.wopee.io';
+const DEFAULT_API_URL = 'https://api.wopee.io';
+/**
+ * Where each configuration value comes from. The SDK is handed a config object
+ * and never reads the environment itself, so the environment variable is named
+ * as the usual source rather than as the thing that was validated.
+ */
+const CONFIG_FIELD_HINTS = {
+    apiKey: `Get it from Project Settings → API Keys at ${CMD_URL}\n    (usually the WOPEE_API_KEY environment variable).`,
+    projectUuid: `Get it from Project Settings at ${CMD_URL}\n    (usually the WOPEE_PROJECT_UUID environment variable).`,
+    apiUrl: `This is your Wopee instance URL (usually the WOPEE_API_URL environment\n    variable). The default SaaS endpoint is ${DEFAULT_API_URL}.`,
+};
+/**
+ * Strips credentials out of a proxy URL. `HTTPS_PROXY` commonly embeds
+ * `user:password@`, and these messages end up in CI logs.
+ */
+function redactProxyUrl(raw) {
+    try {
+        const parsed = new URL(raw);
+        if (parsed.username || parsed.password) {
+            parsed.username = '***';
+            parsed.password = '***';
+        }
+        return parsed.toString();
+    }
+    catch {
+        return '(unparsable proxy URL)';
+    }
+}
+function describeProxy(decision) {
+    if (decision.proxyUrl) {
+        return `${redactProxyUrl(decision.proxyUrl)} (from HTTPS_PROXY/HTTP_PROXY)`;
+    }
+    if (decision.bypassedByNoProxy) {
+        return `bypassed — this host matches NO_PROXY="${decision.noProxy}"`;
+    }
+    return `none — no HTTP_PROXY/HTTPS_PROXY matched this URL (NO_PROXY="${decision.noProxy}")`;
+}
+/**
+ * The middle "likely cause" is the one that changes with the proxy situation —
+ * telling someone to set HTTPS_PROXY when it is already set is noise.
+ */
+function proxyCause(decision) {
+    if (decision.proxyUrl) {
+        return [
+            '2. The proxy itself may be down, or may not allow this host. Verify the',
+            '   proxy is reachable, or add the host to NO_PROXY if it should be',
+            '   reached directly.',
+        ].join('\n    ');
+    }
+    if (decision.bypassedByNoProxy) {
+        return [
+            '2. This host is excluded from the proxy by NO_PROXY. Remove the matching',
+            '   entry if the proxy is how you reach it.',
+        ].join('\n    ');
+    }
+    return [
+        '2. A corporate proxy is required to reach it. The Wopee SDK honours',
+        '   HTTP_PROXY, HTTPS_PROXY and NO_PROXY — set HTTPS_PROXY and retry.',
+    ].join('\n    ');
+}
+/**
+ * Turns a zod validation failure into readable prose. Fields without a hint fall
+ * back to the bare zod message, so every config failure reads as a sentence
+ * rather than a ZodError dump.
+ */
+function toConfigError(error) {
+    const details = error.issues.map((issue) => {
+        const field = issue.path.join('.');
+        const hint = CONFIG_FIELD_HINTS[field];
+        const headline = `  • ${field || 'configuration'}: ${issue.message}.`;
+        return hint ? `${headline}\n    ${hint}` : headline;
+    });
+    const message = [
+        'Wopee SDK configuration is invalid — cannot initialize.',
+        '',
+        ...details,
+        '',
+        `Docs: ${DOCS_URL}`,
+    ].join('\n');
+    return new shared_1.WopeeError(message, { code: 'WOPEE_CONFIG_INVALID', cause: error });
+}
+function unreachableMessage(apiUrl, failure, code) {
+    const decision = (0, axios_config_1.getProxyDecision)(apiUrl);
+    const failureLine = code ? `${failure} (${code})` : failure;
+    return [
+        `Cannot reach the Wopee API at ${apiUrl}.`,
+        '',
+        `  Attempted:  POST ${apiUrl}`,
+        `  Failure:    ${failureLine}`,
+        `  Proxy:      ${describeProxy(decision)}`,
+        '',
+        '  Likely causes:',
+        '    1. This is a self-hosted Wopee instance that is only reachable from the',
+        '       customer network. Connect to the VPN, or run the tests from a CI',
+        '       runner inside that network.',
+        `    ${proxyCause(decision)}`,
+        '    3. WOPEE_API_URL points at the wrong host. Confirm the value with your',
+        `       Wopee administrator; the default SaaS endpoint is ${DEFAULT_API_URL}.`,
+        '',
+        `  Docs: ${DOCS_URL}`,
+    ].join('\n');
+}
+function unauthorizedMessage(apiUrl, status, projectUuid) {
+    const label = status === 403 ? 'Forbidden' : 'Unauthorized';
+    return [
+        `Wopee API rejected the request: ${status} ${label}.`,
+        '',
+        `  Endpoint:    ${apiUrl}`,
+        `  Project:     ${projectUuid ?? '(not set)'}`,
+        '',
+        '  The API key was not accepted. Check WOPEE_API_KEY — you can view or',
+        `  regenerate it under Project Settings → API Keys at ${CMD_URL}.`,
+        '  Make sure the key belongs to the project above.',
+        '',
+        `  Docs: ${DOCS_URL}`,
+    ].join('\n');
+}
+/**
+ * Pulls the GraphQL error the API returns in the response body, which the
+ * previous implementation discarded.
+ */
+function serverMessage(data) {
+    const errors = data?.errors;
+    const message = Array.isArray(errors) ? errors[0]?.message : undefined;
+    return typeof message === 'string' && message.length > 0 ? message : null;
+}
+/**
+ * Wraps a failed API call in a `WopeeError` that says what to do about it.
+ *
+ * The discriminator for "unreachable" is the absence of a response rather than
+ * an errno allowlist — that covers DNS, TCP, TLS and proxy-tunnel failures
+ * without going stale.
+ */
+function toApiRequestError(error, context) {
+    const { apiUrl, projectUuid } = context;
+    if (axios_1.default.isAxiosError(error)) {
+        if (!error.response) {
+            return new shared_1.WopeeError(unreachableMessage(apiUrl, error.message, error.code), {
+                code: 'WOPEE_API_UNREACHABLE',
+                cause: error,
+            });
+        }
+        const status = error.response.status;
+        if (status === 401 || status === 403) {
+            return new shared_1.WopeeError(unauthorizedMessage(apiUrl, status, projectUuid), {
+                code: 'WOPEE_API_UNAUTHORIZED',
+                cause: error,
+            });
+        }
+        // Keeps the historical "API request failed with status code" wording so
+        // anything matching on it keeps working.
+        const details = serverMessage(error.response.data);
+        const message = [
+            `Wopee API request failed with status code ${status} at ${apiUrl}.`,
+            error.message,
+            ...(details ? [`Server said: ${details}`] : []),
+        ].join('\n');
+        return new shared_1.WopeeError(message, { code: 'WOPEE_API_ERROR', cause: error });
+    }
+    const description = error instanceof Error ? error.message : String(error);
+    return new shared_1.WopeeError(`Unexpected error during the Wopee API call: ${description}`, {
+        code: 'WOPEE_API_ERROR',
+        cause: error,
+    });
+}
+//# sourceMappingURL=errors.js.map

package/node_modules/@autonomous-testing/sdk/build/infrastructure/adapters/apolloAdapter/factories.js

@@ -116,6 +116,7 @@ function createIntegrationStepApolloPayloadFactory(config, integrationScenario,
     const configPayload = interface_1.CreateIntegrationStepConfigApolloPayloadSchema.parse(rawConfigPayload);
     return interface_1.CreateIntegrationStepApolloPayloadSchema.parse({
         browser: configPayload.browser,
+        device: configPayload.device,
         comment: configPayload.comment,
         customTags: configPayload.customTags,
         imageBase64: createIntegrationStepPayload.imageBase64,

package/node_modules/@autonomous-testing/sdk/build/infrastructure/adapters/apolloAdapter/interface.d.ts

@@ -16,10 +16,10 @@ declare const ApolloAdapterConfigSchema: z.ZodObject<{
     suiteUuid: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     apiKey: string;
+    projectUuid: string;
     apiUrl: string;
     branchName: string;
     enableSoftAssert: boolean;
-    projectUuid: string;
     browser?: string | undefined;
     comment?: string | undefined;
     customTags?: string | undefined;
@@ -157,6 +157,7 @@ declare const CreateIntegrationStepConfigApolloPayloadSchema: z.ZodObject<{
 type CreateIntegrationStepConfigApolloPayload = z.infer<typeof CreateIntegrationStepConfigApolloPayloadSchema>;
 declare const CreateIntegrationStepApolloPayloadSchema: z.ZodObject<{
     browser: z.ZodOptional<z.ZodString>;
+    device: z.ZodOptional<z.ZodString>;
     comment: z.ZodOptional<z.ZodString>;
     customTags: z.ZodOptional<z.ZodString>;
     ignoreAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -200,6 +201,7 @@ declare const CreateIntegrationStepApolloPayloadSchema: z.ZodObject<{
     viewport?: string | undefined;
     pageContentBase64?: string | null | undefined;
     baselineBranchName?: string | undefined;
+    device?: string | undefined;
     ignoreAreas?: {
         height: number;
         width: number;
@@ -220,6 +222,7 @@ declare const CreateIntegrationStepApolloPayloadSchema: z.ZodObject<{
     viewport?: string | undefined;
     pageContentBase64?: string | null | undefined;
     baselineBranchName?: string | undefined;
+    device?: string | undefined;
     ignoreAreas?: {
         height: number;
         width: number;

package/node_modules/@autonomous-testing/sdk/build/infrastructure/adapters/apolloAdapter/interface.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisualAssertApolloResponseSchema = exports.VisualAssertApolloPayloadSchema = exports.SuiteIntegrationConfigApolloPayloadSchema = exports.StopIntegrationScenarioApolloPayloadSchema = exports.IgnoreAreaApolloPayloadSchema = exports.CreateIntegrationSuiteApolloPayloadSchema = exports.CreateIntegrationStepConfigApolloPayloadSchema = exports.CreateIntegrationStepApolloResponseSchema = exports.CreateIntegrationStepApolloPayloadSchema = exports.CreateIntegrationScenarioApolloPayloadSchema = exports.ApolloAdapterConfigSchema = void 0;
 const shared_1 = require("../../../shared");
 const zod_1 = require("zod");
+// The messages below are rendered into a human-readable summary by
+// `toConfigError` in ./errors.ts, so they read as a sentence fragment following
+// the field name, e.g. "apiKey: missing.".
 const ApolloAdapterConfigSchema = zod_1.z.object({
-    apiKey: zod_1.z.string(),
-    apiUrl: zod_1.z.string().default('https://api.wopee.io'),
+    apiKey: zod_1.z
+        .string({ required_error: 'missing', invalid_type_error: 'must be a string' })
+        .min(1, 'missing (empty string)'),
+    apiUrl: zod_1.z
+        .string({ invalid_type_error: 'must be a string' })
+        .url('must be an absolute URL including the scheme, e.g. https://api.wopee.io')
+        .default('https://api.wopee.io'),
     branchName: zod_1.z.string().default('master'),
     browser: zod_1.z.string().optional(),
     comment: zod_1.z.string().optional(),
@@ -14,7 +22,9 @@ const ApolloAdapterConfigSchema = zod_1.z.object({
     enableSoftAssert: shared_1.ZodHelper.parseStringToBoolean().default(true),
     os: zod_1.z.string().optional(),
     pixelToPixelDiffTolerance: shared_1.ZodHelper.parseStringToNumberSchema().optional(),
-    projectUuid: zod_1.z.string(),
+    projectUuid: zod_1.z
+        .string({ required_error: 'missing', invalid_type_error: 'must be a string' })
+        .min(1, 'missing (empty string)'),
     viewport: zod_1.z.string().optional(),
     baselineBranchName: zod_1.z.string().optional(),
     suiteUuid: zod_1.z.string().optional(),
@@ -63,6 +73,7 @@ const CreateIntegrationStepConfigApolloPayloadSchema = zod_1.z.object({
 exports.CreateIntegrationStepConfigApolloPayloadSchema = CreateIntegrationStepConfigApolloPayloadSchema;
 const CreateIntegrationStepApolloPayloadSchema = zod_1.z.object({
     browser: zod_1.z.string().optional(),
+    device: zod_1.z.string().optional(),
     comment: zod_1.z.string().optional(),
     customTags: zod_1.z.string().optional(),
     ignoreAreas: zod_1.z.array(IgnoreAreaApolloPayloadSchema).optional(),

package/node_modules/@autonomous-testing/sdk/build/infrastructure/services/apolloAdapterService/apolloAdapterService.js

@@ -3,10 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApolloTrackAdapter = createApolloTrackAdapter;
 const adapters_1 = require("../../adapters");
 const adapters_2 = require("../../adapters");
+const errors_1 = require("../../adapters/apolloAdapter/errors");
 const loggerService_1 = require("../loggerService");
 function createApolloTrackAdapter(apolloAdapterOptions) {
     const logger = (0, loggerService_1.createLogger)(apolloAdapterOptions.loggerOptions);
-    const apolloAdapterConfig = adapters_2.ApolloAdapterConfigSchema.parse(apolloAdapterOptions.apolloAdapterConfig);
-    return new adapters_1.ApolloAdapter(apolloAdapterConfig, logger);
+    const parsed = adapters_2.ApolloAdapterConfigSchema.safeParse(apolloAdapterOptions.apolloAdapterConfig);
+    if (!parsed.success) {
+        throw (0, errors_1.toConfigError)(parsed.error);
+    }
+    return new adapters_1.ApolloAdapter(parsed.data, logger);
 }
 //# sourceMappingURL=apolloAdapterService.js.map

package/node_modules/@autonomous-testing/sdk/build/shared/metadata/versionMetadata.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hash = exports.version = void 0;
-exports.version = "3.6.0"
-exports.hash = "491c8181f954b65844e6a38969c64cc45e8f5b22"
+exports.version = "3.9.0"
+exports.hash = "0563bb7e8a10da7649566d51b13fb4bef3ee3f5c"
 //# sourceMappingURL=versionMetadata.js.map

package/node_modules/@autonomous-testing/sdk/build/shared/utils/error.interface.d.ts

@@ -1,4 +1,16 @@
+/**
+ * Stable, machine-readable identifiers for the failure modes the SDK reports.
+ *
+ * Prefer branching on `WopeeError.code` over matching on the message text —
+ * messages are written for humans and may be reworded.
+ */
+export type WopeeErrorCode = 'WOPEE_CONFIG_INVALID' | 'WOPEE_API_UNREACHABLE' | 'WOPEE_API_UNAUTHORIZED' | 'WOPEE_API_ERROR';
+export interface WopeeErrorOptions {
+    code?: WopeeErrorCode;
+    cause?: unknown;
+}
 export declare class WopeeError extends Error {
-    constructor(message: string);
+    readonly code?: WopeeErrorCode;
+    constructor(message: string, options?: WopeeErrorOptions);
 }
 //# sourceMappingURL=error.interface.d.ts.map

package/node_modules/@autonomous-testing/sdk/build/shared/utils/error.interface.js

@@ -2,9 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WopeeError = void 0;
 class WopeeError extends Error {
-    constructor(message) {
+    code;
+    constructor(message, options = {}) {
         super(message);
         this.name = 'WopeeError';
+        this.code = options.code;
+        // Assigned rather than passed to `super` so the SDK does not depend on
+        // the Error constructor accepting an options bag.
+        if (options.cause !== undefined) {
+            this.cause = options.cause;
+        }
         Object.setPrototypeOf(this, WopeeError.prototype);
     }
 }

package/node_modules/@autonomous-testing/sdk/build/shared/utils/index.d.ts

@@ -1,5 +1,5 @@
-import { WopeeError } from './error.interface';
+import { WopeeError, WopeeErrorCode, WopeeErrorOptions } from './error.interface';
 export * from './mergeDicts';
 export * from './zodHelper';
-export { WopeeError };
+export { WopeeError, WopeeErrorCode, WopeeErrorOptions };
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@autonomous-testing/sdk/node_modules/agent-base/README.md

@@ -0,0 +1,145 @@
+agent-base
+==========
+### Turn a function into an [`http.Agent`][http.Agent] instance
+[![Build Status](https://github.com/TooTallNate/node-agent-base/workflows/Node%20CI/badge.svg)](https://github.com/TooTallNate/node-agent-base/actions?workflow=Node+CI)
+
+This module provides an `http.Agent` generator. That is, you pass it an async
+callback function, and it returns a new `http.Agent` instance that will invoke the
+given callback function when sending outbound HTTP requests.
+
+#### Some subclasses:
+
+Here's some more interesting uses of `agent-base`.
+Send a pull request to list yours!
+
+ * [`http-proxy-agent`][http-proxy-agent]: An HTTP(s) proxy `http.Agent` implementation for HTTP endpoints
+ * [`https-proxy-agent`][https-proxy-agent]: An HTTP(s) proxy `http.Agent` implementation for HTTPS endpoints
+ * [`pac-proxy-agent`][pac-proxy-agent]: A PAC file proxy `http.Agent` implementation for HTTP and HTTPS
+ * [`socks-proxy-agent`][socks-proxy-agent]: A SOCKS proxy `http.Agent` implementation for HTTP and HTTPS
+
+
+Installation
+------------
+
+Install with `npm`:
+
+``` bash
+$ npm install agent-base
+```
+
+
+Example
+-------
+
+Here's a minimal example that creates a new `net.Socket` connection to the server
+for every HTTP request (i.e. the equivalent of `agent: false` option):
+
+```js
+var net = require('net');
+var tls = require('tls');
+var url = require('url');
+var http = require('http');
+var agent = require('agent-base');
+
+var endpoint = 'http://nodejs.org/api/';
+var parsed = url.parse(endpoint);
+
+// This is the important part!
+parsed.agent = agent(function (req, opts) {
+  var socket;
+  // `secureEndpoint` is true when using the https module
+  if (opts.secureEndpoint) {
+    socket = tls.connect(opts);
+  } else {
+    socket = net.connect(opts);
+  }
+  return socket;
+});
+
+// Everything else works just like normal...
+http.get(parsed, function (res) {
+  console.log('"response" event!', res.headers);
+  res.pipe(process.stdout);
+});
+```
+
+Returning a Promise or using an `async` function is also supported:
+
+```js
+agent(async function (req, opts) {
+  await sleep(1000);
+  // etc…
+});
+```
+
+Return another `http.Agent` instance to "pass through" the responsibility
+for that HTTP request to that agent:
+
+```js
+agent(function (req, opts) {
+  return opts.secureEndpoint ? https.globalAgent : http.globalAgent;
+});
+```
+
+
+API
+---
+
+## Agent(Function callback[, Object options]) → [http.Agent][]
+
+Creates a base `http.Agent` that will execute the callback function `callback`
+for every HTTP request that it is used as the `agent` for. The callback function
+is responsible for creating a `stream.Duplex` instance of some kind that will be
+used as the underlying socket in the HTTP request.
+
+The `options` object accepts the following properties:
+
+  * `timeout` - Number - Timeout for the `callback()` function in milliseconds. Defaults to Infinity (optional).
+
+The callback function should have the following signature:
+
+### callback(http.ClientRequest req, Object options, Function cb) → undefined
+
+The ClientRequest `req` can be accessed to read request headers and
+and the path, etc. The `options` object contains the options passed
+to the `http.request()`/`https.request()` function call, and is formatted
+to be directly passed to `net.connect()`/`tls.connect()`, or however
+else you want a Socket to be created. Pass the created socket to
+the callback function `cb` once created, and the HTTP request will
+continue to proceed.
+
+If the `https` module is used to invoke the HTTP request, then the
+`secureEndpoint` property on `options` _will be set to `true`_.
+
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+[http-proxy-agent]: https://github.com/TooTallNate/node-http-proxy-agent
+[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
+[pac-proxy-agent]: https://github.com/TooTallNate/node-pac-proxy-agent
+[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
+[http.Agent]: https://nodejs.org/api/http.html#http_class_http_agent

package/node_modules/@autonomous-testing/sdk/node_modules/agent-base/dist/src/index.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="node" />
+import net from 'net';
+import http from 'http';
+import https from 'https';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+declare function createAgent(opts?: createAgent.AgentOptions): createAgent.Agent;
+declare function createAgent(callback: createAgent.AgentCallback, opts?: createAgent.AgentOptions): createAgent.Agent;
+declare namespace createAgent {
+    interface ClientRequest extends http.ClientRequest {
+        _last?: boolean;
+        _hadError?: boolean;
+        method: string;
+    }
+    interface AgentRequestOptions {
+        host?: string;
+        path?: string;
+        port: number;
+    }
+    interface HttpRequestOptions extends AgentRequestOptions, Omit<http.RequestOptions, keyof AgentRequestOptions> {
+        secureEndpoint: false;
+    }
+    interface HttpsRequestOptions extends AgentRequestOptions, Omit<https.RequestOptions, keyof AgentRequestOptions> {
+        secureEndpoint: true;
+    }
+    type RequestOptions = HttpRequestOptions | HttpsRequestOptions;
+    type AgentLike = Pick<createAgent.Agent, 'addRequest'> | http.Agent;
+    type AgentCallbackReturn = Duplex | AgentLike;
+    type AgentCallbackCallback = (err?: Error | null, socket?: createAgent.AgentCallbackReturn) => void;
+    type AgentCallbackPromise = (req: createAgent.ClientRequest, opts: createAgent.RequestOptions) => createAgent.AgentCallbackReturn | Promise<createAgent.AgentCallbackReturn>;
+    type AgentCallback = typeof Agent.prototype.callback;
+    type AgentOptions = {
+        timeout?: number;
+    };
+    /**
+     * Base `http.Agent` implementation.
+     * No pooling/keep-alive is implemented by default.
+     *
+     * @param {Function} callback
+     * @api public
+     */
+    class Agent extends EventEmitter {
+        timeout: number | null;
+        maxFreeSockets: number;
+        maxTotalSockets: number;
+        maxSockets: number;
+        sockets: {
+            [key: string]: net.Socket[];
+        };
+        freeSockets: {
+            [key: string]: net.Socket[];
+        };
+        requests: {
+            [key: string]: http.IncomingMessage[];
+        };
+        options: https.AgentOptions;
+        private promisifiedCallback?;
+        private explicitDefaultPort?;
+        private explicitProtocol?;
+        constructor(callback?: createAgent.AgentCallback | createAgent.AgentOptions, _opts?: createAgent.AgentOptions);
+        get defaultPort(): number;
+        set defaultPort(v: number);
+        get protocol(): string;
+        set protocol(v: string);
+        callback(req: createAgent.ClientRequest, opts: createAgent.RequestOptions, fn: createAgent.AgentCallbackCallback): void;
+        callback(req: createAgent.ClientRequest, opts: createAgent.RequestOptions): createAgent.AgentCallbackReturn | Promise<createAgent.AgentCallbackReturn>;
+        /**
+         * Called by node-core's "_http_client.js" module when creating
+         * a new HTTP request with this Agent instance.
+         *
+         * @api public
+         */
+        addRequest(req: ClientRequest, _opts: RequestOptions): void;
+        freeSocket(socket: net.Socket, opts: AgentOptions): void;
+        destroy(): void;
+    }
+}
+export = createAgent;