@sentry/node 7.105.0 → 8.0.0-alpha.2

package/types/sdk.d.ts

@@ -1,74 +0,0 @@
-import type { Integration, Options, StackParser } from '@sentry/types';
-import { NodeClient } from './client';
-import type { NodeOptions } from './types';
-/** @deprecated Use `getDefaultIntegrations(options)` instead. */
-export declare const defaultIntegrations: import("@sentry/types").IntegrationFnResult[];
-/** Get the default integrations for the Node SDK. */
-export declare function getDefaultIntegrations(_options: Options): Integration[];
-/**
- * The Sentry Node SDK Client.
- *
- * To use this SDK, call the {@link init} function as early as possible in the
- * main entry module. To set context information or send manual events, use the
- * provided methods.
- *
- * @example
- * ```
- *
- * const { init } = require('@sentry/node');
- *
- * init({
- *   dsn: '__DSN__',
- *   // ...
- * });
- * ```
- *
- * @example
- * ```
- *
- * const { configureScope } = require('@sentry/node');
- * configureScope((scope: Scope) => {
- *   scope.setExtra({ battery: 0.7 });
- *   scope.setTag({ user_mode: 'admin' });
- *   scope.setUser({ id: '4711' });
- * });
- * ```
- *
- * @example
- * ```
- *
- * const { addBreadcrumb } = require('@sentry/node');
- * addBreadcrumb({
- *   message: 'My Breadcrumb',
- *   // ...
- * });
- * ```
- *
- * @example
- * ```
- *
- * const Sentry = require('@sentry/node');
- * Sentry.captureMessage('Hello, world!');
- * Sentry.captureException(new Error('Good bye'));
- * Sentry.captureEvent({
- *   message: 'Manual',
- *   stacktrace: [
- *     // ...
- *   ],
- * });
- * ```
- *
- * @see {@link NodeOptions} for documentation on configuration options.
- */
-export declare function init(options?: NodeOptions): void;
-/**
- * Function that takes an instance of NodeClient and checks if autoSessionTracking option is enabled for that client
- */
-export declare function isAutoSessionTrackingEnabled(client?: NodeClient): boolean;
-/**
- * Returns a release dynamically from environment variables.
- */
-export declare function getSentryRelease(fallback?: string): string | undefined;
-/** Node.js stack parser */
-export declare const defaultStackParser: StackParser;
-//# sourceMappingURL=sdk.d.ts.map

package/types/sdk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/sdk.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAiB,WAAW,EAAE,MAAM,eAAe,CAAC;AAUtF,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAatC,OAAO,KAAK,EAAqB,WAAW,EAAE,MAAM,SAAS,CAAC;AAE9D,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,+CAkB/B,CAAC;AAEF,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,EAAE,CAUvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,IAAI,CAuEpD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CASzE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA6BtE;AAED,2BAA2B;AAC3B,eAAO,MAAM,kBAAkB,EAAE,WAAmF,CAAC"}

package/types/tracing/index.d.ts

@@ -1,6 +0,0 @@
-import type { Integration } from '@sentry/types';
-/**
- * Automatically detects and returns integrations that will work with your dependencies.
- */
-export declare function autoDiscoverNodePerformanceMonitoringIntegrations(): Integration[];
-//# sourceMappingURL=index.d.ts.map

package/types/tracing/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tracing/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD;;GAEG;AACH,wBAAgB,iDAAiD,IAAI,WAAW,EAAE,CAiBjF"}

package/types/tracing/integrations.d.ts

@@ -1,2 +0,0 @@
-export { Apollo, Express, GraphQL, Mongo, Mysql, Postgres, Prisma } from '@sentry-internal/tracing';
-//# sourceMappingURL=integrations.d.ts.map

package/types/tracing/integrations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../../../src/tracing/integrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC"}

package/types/utils.d.ts

@@ -1,10 +0,0 @@
-/**
- * Recursively read the contents of a directory.
- *
- * @param targetDir Absolute or relative path of the directory to scan. All returned paths will be relative to this
- * directory.
- * @returns Array holding all relative paths
- * @deprecated This function will be removed in the next major version.
- */
-export declare function deepReadDirSync(targetDir: string): string[];
-//# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CA4B3D"}

package/types-ts3.8/async/domain.d.ts

@@ -1,5 +0,0 @@
-/**
- * Sets the async context strategy to use Node.js domains.
- */
-export declare function setDomainAsyncContextStrategy(): void;
-//# sourceMappingURL=domain.d.ts.map

package/types-ts3.8/async/hooks.d.ts

@@ -1,5 +0,0 @@
-/**
- * Sets the async context strategy to use AsyncLocalStorage which requires Node v12.17.0 or v13.10.0.
- */
-export declare function setHooksAsyncContextStrategy(): void;
-//# sourceMappingURL=hooks.d.ts.map

package/types-ts3.8/async/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Sets the correct async context strategy for Node.js
- *
- * Node.js >= 14 uses AsyncLocalStorage
- * Node.js < 14 uses domains
- */
-export declare function setNodeAsyncContextStrategy(): void;
-//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/client.d.ts

@@ -1,16 +0,0 @@
-import { ServerRuntimeClient } from '@sentry/core';
-import { NodeClientOptions } from './types';
-/**
- * The Sentry Node SDK Client.
- *
- * @see NodeClientOptions for documentation on configuration options.
- * @see SentryClient for usage documentation.
- */
-export declare class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
-    /**
-     * Creates a new Node SDK instance.
-     * @param options Configuration options for this SDK.
-     */
-    constructor(options: NodeClientOptions);
-}
-//# sourceMappingURL=client.d.ts.map

package/types-ts3.8/handlers.d.ts

@@ -1,57 +0,0 @@
-/// <reference types="node" />
-import * as http from 'http';
-import { AddRequestDataToEventOptions } from '@sentry/utils';
-import { ParseRequestOptions } from './requestDataDeprecated';
-/**
- * Express-compatible tracing handler.
- * @see Exposed as `Handlers.tracingHandler`
- */
-export declare function tracingHandler(): (req: http.IncomingMessage, res: http.ServerResponse, next: (error?: any) => void) => void;
-export type RequestHandlerOptions = (ParseRequestOptions | AddRequestDataToEventOptions) & {
-    flushTimeout?: number;
-};
-/**
- * Express compatible request handler.
- * @see Exposed as `Handlers.requestHandler`
- */
-export declare function requestHandler(options?: RequestHandlerOptions): (req: http.IncomingMessage, res: http.ServerResponse, next: (error?: any) => void) => void;
-/** JSDoc */
-interface MiddlewareError extends Error {
-    status?: number | string;
-    statusCode?: number | string;
-    status_code?: number | string;
-    output?: {
-        statusCode?: number | string;
-    };
-}
-/**
- * Express compatible error handler.
- * @see Exposed as `Handlers.errorHandler`
- */
-export declare function errorHandler(options?: {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * @param error Captured middleware error
-     */
-    shouldHandleError?(this: void, error: MiddlewareError): boolean;
-}): (error: MiddlewareError, req: http.IncomingMessage, res: http.ServerResponse, next: (error: MiddlewareError) => void) => void;
-interface SentryTrpcMiddlewareOptions {
-    /** Whether to include procedure inputs in reported events. Defaults to `false`. */
-    attachRpcInput?: boolean;
-}
-interface TrpcMiddlewareArguments<T> {
-    path: string;
-    type: string;
-    next: () => T;
-    rawInput: unknown;
-}
-/**
- * Sentry tRPC middleware that names the handling transaction after the called procedure.
- *
- * Use the Sentry tRPC middleware in combination with the Sentry server integration,
- * e.g. Express Request Handlers or Next.js SDK.
- */
-export declare function trpcMiddleware(options?: SentryTrpcMiddlewareOptions): <T>({ path, type, next, rawInput }: TrpcMiddlewareArguments<T>) => T;
-export { ParseRequestOptions, ExpressRequest } from './requestDataDeprecated';
-export { parseRequest, extractRequestData } from './requestDataDeprecated';
-//# sourceMappingURL=handlers.d.ts.map

package/types-ts3.8/integrations/anr/legacy.d.ts

@@ -1,22 +0,0 @@
-interface LegacyOptions {
-    entryScript: string;
-    pollInterval: number;
-    anrThreshold: number;
-    captureStackTrace: boolean;
-    debug: boolean;
-}
-/**
- * @deprecated Use the `Anr` integration instead.
- *
- * ```ts
- * import * as Sentry from '@sentry/node';
- *
- * Sentry.init({
- *   dsn: '__DSN__',
- *   integrations: [new Sentry.Integrations.Anr({ captureStackTrace: true })],
- * });
- * ```
- */
-export declare function enableAnrDetection(options: Partial<LegacyOptions>): Promise<void>;
-export {};
-//# sourceMappingURL=legacy.d.ts.map

package/types-ts3.8/integrations/hapi/index.d.ts

@@ -1,22 +0,0 @@
-export declare const hapiErrorPlugin: {
-    name: string;
-    version: string;
-    register: (serverArg: Record<any, any>) => Promise<void>;
-};
-export declare const hapiTracingPlugin: {
-    name: string;
-    version: string;
-    register: (serverArg: Record<any, any>) => Promise<void>;
-};
-export type HapiOptions = {
-    /** Hapi server instance */
-    server?: Record<any, any>;
-};
-export declare const hapiIntegration: (options?: HapiOptions | undefined) => import("@sentry/types").IntegrationFnResult;
-/**
- * Hapi Framework Integration.
- * @deprecated Use `hapiIntegration()` instead.
- */
-export declare const Hapi: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration>;
-export type Hapi = typeof Hapi;
-//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/index.d.ts

@@ -1,14 +0,0 @@
-export { Console } from './console';
-export { Http } from './http';
-export { OnUncaughtException } from './onuncaughtexception';
-export { OnUnhandledRejection } from './onunhandledrejection';
-export { Modules } from './modules';
-export { ContextLines } from './contextlines';
-export { Context } from './context';
-export { RequestData } from '@sentry/core';
-export { LocalVariables } from './local-variables';
-export { Undici } from './undici';
-export { Spotlight } from './spotlight';
-export { Anr } from './anr';
-export { Hapi } from './hapi';
-//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/local-variables/local-variables-async.d.ts

@@ -1,14 +0,0 @@
-import { Event, Integration, IntegrationClass } from '@sentry/types';
-import { NodeClient } from '../../client';
-import { LocalVariablesIntegrationOptions } from './common';
-export declare const localVariablesAsyncIntegration: (options?: LocalVariablesIntegrationOptions | undefined) => import("@sentry/types").IntegrationFnResult;
-/**
- * Adds local variables to exception frames.
- * @deprecated Use `localVariablesAsyncIntegration()` instead.
- */
-export declare const LocalVariablesAsync: IntegrationClass<Integration & {
-    processEvent: (event: Event) => Event;
-    setup: (client: NodeClient) => void;
-}>;
-export type LocalVariablesAsync = typeof LocalVariablesAsync;
-//# sourceMappingURL=local-variables-async.d.ts.map

package/types-ts3.8/integrations/undici/index.d.ts

@@ -1,58 +0,0 @@
-import { EventProcessor, Integration, IntegrationFnResult } from '@sentry/types';
-export declare enum ChannelName {
-    RequestCreate = "undici:request:create",
-    RequestEnd = "undici:request:headers",
-    RequestError = "undici:request:error"
-}
-export interface UndiciOptions {
-    /**
-     * Whether breadcrumbs should be recorded for requests
-     * Defaults to true
-     */
-    breadcrumbs: boolean;
-    /**
-     * Whether tracing spans should be created for requests
-     * If not set, this will be enabled/disabled based on if tracing is enabled.
-     */
-    tracing?: boolean;
-    /**
-     * Function determining whether or not to create spans to track outgoing requests to the given URL.
-     * By default, spans will be created for all outgoing requests.
-     */
-    shouldCreateSpanForRequest?: (url: string) => boolean;
-}
-export declare const nativeNodeFetchintegration: (options?: Partial<UndiciOptions> | undefined) => IntegrationFnResult;
-/**
- * Instruments outgoing HTTP requests made with the `undici` package via
- * Node's `diagnostics_channel` API.
- *
- * Supports Undici 4.7.0 or higher.
- *
- * Requires Node 16.17.0 or higher.
- *
- * @deprecated Use `nativeNodeFetchintegration()` instead.
- */
-export declare class Undici implements Integration {
-    /**
-     * @inheritDoc
-     */
-    static id: string;
-    /**
-     * @inheritDoc
-     */
-    name: string;
-    private readonly _options;
-    private readonly _createSpanUrlMap;
-    private readonly _headersUrlMap;
-    constructor(_options?: Partial<UndiciOptions>);
-    /**
-     * @inheritDoc
-     */
-    setupOnce(_addGlobalEventProcessor: (callback: EventProcessor) => void): void;
-    /** Helper that wraps shouldCreateSpanForRequest option */
-    private _shouldCreateSpan;
-    private _onRequestCreate;
-    private _onRequestEnd;
-    private _onRequestError;
-}
-//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/undici/types.d.ts

@@ -1,223 +0,0 @@
-/// <reference types="node" />
-import { URL } from 'url';
-import { Span } from '@sentry/types';
-export type ChannelListener = (message: unknown, name: string | symbol) => void;
-/**
- * The `diagnostics_channel` module provides an API to create named channels
- * to report arbitrary message data for diagnostics purposes.
- *
- * It can be accessed using:
- *
- * ```js
- * import diagnostics_channel from 'diagnostics_channel';
- * ```
- *
- * It is intended that a module writer wanting to report diagnostics messages
- * will create one or many top-level channels to report messages through.
- * Channels may also be acquired at runtime but it is not encouraged
- * due to the additional overhead of doing so. Channels may be exported for
- * convenience, but as long as the name is known it can be acquired anywhere.
- *
- * If you intend for your module to produce diagnostics data for others to
- * consume it is recommended that you include documentation of what named
- * channels are used along with the shape of the message data. Channel names
- * should generally include the module name to avoid collisions with data from
- * other modules.
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/diagnostics_channel.js)
- */
-export interface DiagnosticsChannel {
-    /**
-     * Check if there are active subscribers to the named channel. This is helpful if
-     * the message you want to send might be expensive to prepare.
-     *
-     * This API is optional but helpful when trying to publish messages from very
-     * performance-sensitive code.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * if (diagnostics_channel.hasSubscribers('my-channel')) {
-     *   // There are subscribers, prepare and publish message
-     * }
-     * ```
-     * @since v15.1.0, v14.17.0
-     * @param name The channel name
-     * @return If there are active subscribers
-     */
-    hasSubscribers(name: string | symbol): boolean;
-    /**
-     * This is the primary entry-point for anyone wanting to interact with a named
-     * channel. It produces a channel object which is optimized to reduce overhead at
-     * publish time as much as possible.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * const channel = diagnostics_channel.channel('my-channel');
-     * ```
-     * @since v15.1.0, v14.17.0
-     * @param name The channel name
-     * @return The named channel object
-     */
-    channel(name: string | symbol): Channel;
-    /**
-     * Register a message handler to subscribe to this channel. This message handler will be run synchronously
-     * whenever a message is published to the channel. Any errors thrown in the message handler will
-     * trigger an 'uncaughtException'.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * diagnostics_channel.subscribe('my-channel', (message, name) => {
-     *   // Received data
-     * });
-     * ```
-     *
-     * @since v18.7.0, v16.17.0
-     * @param name The channel name
-     * @param onMessage The handler to receive channel messages
-     */
-    subscribe(name: string | symbol, onMessage: ChannelListener): void;
-    /**
-     * Remove a message handler previously registered to this channel with diagnostics_channel.subscribe(name, onMessage).
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * function onMessage(message, name) {
-     *  // Received data
-     * }
-     *
-     * diagnostics_channel.subscribe('my-channel', onMessage);
-     *
-     * diagnostics_channel.unsubscribe('my-channel', onMessage);
-     * ```
-     *
-     * @since v18.7.0, v16.17.0
-     * @param name The channel name
-     * @param onMessage The previous subscribed handler to remove
-     * @returns `true` if the handler was found, `false` otherwise
-     */
-    unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
-}
-/**
- * The class `Channel` represents an individual named channel within the data
- * pipeline. It is use to track subscribers and to publish messages when there
- * are subscribers present. It exists as a separate object to avoid channel
- * lookups at publish time, enabling very fast publish speeds and allowing
- * for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
- * with `new Channel(name)` is not supported.
- * @since v15.1.0, v14.17.0
- */
-interface ChannelI {
-    readonly name: string | symbol;
-    /**
-     * Check if there are active subscribers to this channel. This is helpful if
-     * the message you want to send might be expensive to prepare.
-     *
-     * This API is optional but helpful when trying to publish messages from very
-     * performance-sensitive code.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * const channel = diagnostics_channel.channel('my-channel');
-     *
-     * if (channel.hasSubscribers) {
-     *   // There are subscribers, prepare and publish message
-     * }
-     * ```
-     * @since v15.1.0, v14.17.0
-     */
-    readonly hasSubscribers: boolean;
-    /**
-     * Publish a message to any subscribers to the channel. This will
-     * trigger message handlers synchronously so they will execute within
-     * the same context.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * const channel = diagnostics_channel.channel('my-channel');
-     *
-     * channel.publish({
-     *   some: 'message'
-     * });
-     * ```
-     * @since v15.1.0, v14.17.0
-     * @param message The message to send to the channel subscribers
-     */
-    publish(message: unknown): void;
-    /**
-     * Register a message handler to subscribe to this channel. This message handler
-     * will be run synchronously whenever a message is published to the channel. Any
-     * errors thrown in the message handler will trigger an `'uncaughtException'`.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * const channel = diagnostics_channel.channel('my-channel');
-     *
-     * channel.subscribe((message, name) => {
-     *   // Received data
-     * });
-     * ```
-     * @since v15.1.0, v14.17.0
-     * @param onMessage The handler to receive channel messages
-     */
-    subscribe(onMessage: ChannelListener): void;
-    /**
-     * Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
-     *
-     * ```js
-     * import diagnostics_channel from 'diagnostics_channel';
-     *
-     * const channel = diagnostics_channel.channel('my-channel');
-     *
-     * function onMessage(message, name) {
-     *   // Received data
-     * }
-     *
-     * channel.subscribe(onMessage);
-     *
-     * channel.unsubscribe(onMessage);
-     * ```
-     * @since v15.1.0, v14.17.0
-     * @param onMessage The previous subscribed handler to remove
-     * @return `true` if the handler was found, `false` otherwise.
-     */
-    unsubscribe(onMessage: ChannelListener): void;
-}
-export interface Channel extends ChannelI {
-    new (name: string | symbol): void;
-}
-export interface UndiciRequest {
-    origin?: string | URL;
-    completed: boolean;
-    method?: string;
-    path: string;
-    headers: string;
-    addHeader(key: string, value: string): RequestWithSentry;
-}
-export interface UndiciResponse {
-    statusCode: number;
-    statusText: string;
-    headers: Array<Buffer>;
-}
-export interface RequestWithSentry extends UndiciRequest {
-    __sentry_span__?: Span;
-}
-export interface RequestCreateMessage {
-    request: RequestWithSentry;
-}
-export interface RequestEndMessage {
-    request: RequestWithSentry;
-    response: UndiciResponse;
-}
-export interface RequestErrorMessage {
-    request: RequestWithSentry;
-    error: Error;
-}
-export {};
-//# sourceMappingURL=types.d.ts.map

package/types-ts3.8/integrations/utils/http.d.ts

@@ -1,80 +0,0 @@
-/// <reference types="node" />
-import * as http from 'http';
-import * as https from 'https';
-import { URL } from 'url';
-/**
- * Assembles a URL that's passed to the users to filter on.
- * It can include raw (potentially PII containing) data, which we'll allow users to access to filter
- * but won't include in spans or breadcrumbs.
- *
- * @param requestOptions RequestOptions object containing the component parts for a URL
- * @returns Fully-formed URL
- */
-export declare function extractRawUrl(requestOptions: RequestOptions): string;
-/**
- * Assemble a URL to be used for breadcrumbs and spans.
- *
- * @param requestOptions RequestOptions object containing the component parts for a URL
- * @returns Fully-formed URL
- */
-export declare function extractUrl(requestOptions: RequestOptions): string;
-/**
- * Handle various edge cases in the span description (for spans representing http(s) requests).
- *
- * @param description current `description` property of the span representing the request
- * @param requestOptions Configuration data for the request
- * @param Request Request object
- *
- * @returns The cleaned description
- */
-export declare function cleanSpanDescription(description: string | undefined, requestOptions: RequestOptions, request: http.ClientRequest): string | undefined;
-export type RequestOptions = http.RequestOptions & {
-    hash?: string;
-    search?: string;
-    pathname?: string;
-    href?: string;
-};
-type RequestCallback = (response: http.IncomingMessage) => void;
-export type RequestMethodArgs = [
-    RequestOptions | string | URL,
-    RequestCallback?
-] | [
-    string | URL,
-    RequestOptions,
-    RequestCallback?
-];
-export type RequestMethod = (...args: RequestMethodArgs) => http.ClientRequest;
-/**
- * Convert a URL object into a RequestOptions object.
- *
- * Copied from Node's internals (where it's used in http(s).request() and http(s).get()), modified only to use the
- * RequestOptions type above.
- *
- * See https://github.com/nodejs/node/blob/master/lib/internal/url.js.
- */
-export declare function urlToOptions(url: URL): RequestOptions;
-/**
- * Normalize inputs to `http(s).request()` and `http(s).get()`.
- *
- * Legal inputs to `http(s).request()` and `http(s).get()` can take one of ten forms:
- *     [ RequestOptions | string | URL ],
- *     [ RequestOptions | string | URL, RequestCallback ],
- *     [ string | URL, RequestOptions ], and
- *     [ string | URL, RequestOptions, RequestCallback ].
- *
- * This standardizes to one of two forms: [ RequestOptions ] and [ RequestOptions, RequestCallback ]. A similar thing is
- * done as the first step of `http(s).request()` and `http(s).get()`; this just does it early so that we can interact
- * with the args in a standard way.
- *
- * @param requestArgs The inputs to `http(s).request()` or `http(s).get()`, as an array.
- *
- * @returns Equivalent args of the form [ RequestOptions ] or [ RequestOptions, RequestCallback ].
- */
-export declare function normalizeRequestArgs(httpModule: typeof http | typeof https, requestArgs: RequestMethodArgs): [
-    RequestOptions
-] | [
-    RequestOptions,
-    RequestCallback
-];
-export {};
-//# sourceMappingURL=http.d.ts.map