@fkn/lib 0.9.63 → 0.9.65

package/http-CDhG4bUc.d.ts

@@ -0,0 +1,187 @@
+import { D as RelayChoice } from "./index-Cu5EcdK0.js";
+import { n as Socket, t as Server$1 } from "./net-mVAYXs8e.js";
+import { Buffer } from "buffer";
+import { Stream } from "stream";
+import { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from "http";
+declare namespace http_d_exports {
+  export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, createServer, _default as default, get, globalAgent, request };
+}
+declare const METHODS: string[];
+declare const STATUS_CODES: Record<number, string>;
+interface ParsedHead {
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  httpVersion: string;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
+}
+interface ParserHandlers {
+  onHeaders: (head: ParsedHead) => void;
+  onBody: (chunk: Uint8Array) => void;
+  onComplete: () => void;
+}
+declare class HTTPParser {
+  private readonly mode;
+  private readonly handlers;
+  private buf;
+  private state;
+  private framing;
+  private bodyRemaining;
+  private chunkState;
+  skipBody: boolean;
+  constructor(mode: 'request' | 'response', handlers: ParserHandlers);
+  execute(chunk: Uint8Array): void;
+  finish(): void;
+  private reset;
+  private parseHead;
+  private applyVersion;
+  private addHeader;
+  private setupBody;
+  private consumeBody;
+  private consumeChunked;
+}
+declare class IncomingMessage extends Stream.Readable {
+  httpVersion: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
+  trailers: Record<string, string>;
+  rawTrailers: string[];
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  complete: boolean;
+  socket: Socket;
+  constructor(socket: Socket);
+  /** alias retained for Node compatibility */
+  get connection(): Socket;
+  _applyHead(head: ParsedHead): void;
+  _read(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
+}
+declare abstract class OutgoingMessage extends Stream.Writable {
+  private _headerStore;
+  headersSent: boolean;
+  chunkedEncoding: boolean;
+  finished: boolean;
+  protected _bodyWritten: boolean;
+  abstract socket: Socket | null;
+  setHeader(name: string, value: number | string | readonly string[]): this;
+  getHeader(name: string): number | string | string[] | undefined;
+  getHeaderNames(): string[];
+  getHeaders(): OutgoingHttpHeaders;
+  hasHeader(name: string): boolean;
+  removeHeader(name: string): void;
+  protected _storeHeader(startLine: string): string;
+  protected abstract _shouldSendBody(): boolean;
+  protected abstract _implicitHeader(): void;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+  protected _headBlock?: string;
+}
+interface ServerResponseOptions {
+  req: IncomingMessage;
+}
+declare class ServerResponse extends OutgoingMessage {
+  statusCode: number;
+  statusMessage?: string;
+  private _writeHeadCalled;
+  sendDate: boolean;
+  req: IncomingMessage;
+  socket: Socket | null;
+  _keepAlive: boolean;
+  constructor(req: IncomingMessage);
+  protected _shouldSendBody(): boolean;
+  writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
+  private _appendHeader;
+  protected _implicitHeader(): void;
+  writeContinue(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
+}
+interface ClientRequestArgs extends RequestOptions {
+  host?: string;
+  hostname?: string;
+  port?: number | string;
+  path?: string;
+  /** the relays the request's socket may go through (`RelayChoice`); Node ignores it */
+  relay?: RelayChoice;
+}
+declare class ClientRequest extends OutgoingMessage {
+  method: string;
+  path: string;
+  host: string;
+  protocol: string;
+  socket: Socket;
+  /** alias retained for Node compatibility */
+  get connection(): Socket;
+  res: IncomingMessage | null;
+  aborted: boolean;
+  private _aborted;
+  constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
+  protected _shouldSendBody(): boolean;
+  protected _implicitHeader(): void;
+  private _attachResponseParser;
+  abort(): void;
+  destroy(error?: Error): this;
+  end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  setTimeout(timeout: number, callback?: () => void): this;
+  setNoDelay(noDelay?: boolean): void;
+  setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare class ServerImpl extends Server$1 {
+  constructor(options?: object | RequestListener, requestListener?: RequestListener);
+  private _handleConnection;
+}
+declare const Server: typeof ServerImpl;
+type Server = ServerImpl;
+declare class Agent {
+  maxSockets: number;
+  maxFreeSockets: number;
+  keepAlive: boolean;
+  options: Record<string, unknown>;
+  constructor(options?: Record<string, unknown>);
+  getName(options?: {
+    host?: string;
+    port?: number;
+    localAddress?: string;
+  }): string;
+  destroy(): void;
+}
+declare const globalAgent: Agent;
+declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+declare const _default: {
+  METHODS: string[];
+  STATUS_CODES: Record<number, string>;
+  Agent: typeof Agent;
+  globalAgent: Agent;
+  Server: typeof ServerImpl;
+  ServerResponse: typeof ServerResponse;
+  IncomingMessage: typeof IncomingMessage;
+  ClientRequest: typeof ClientRequest;
+  OutgoingMessage: typeof OutgoingMessage;
+  createServer: typeof createServer;
+  request: typeof request;
+  get: typeof get;
+};
+export { http_d_exports as _, IncomingMessage as a, RequestListener as c, ServerResponse as d, ServerResponseOptions as f, globalAgent as g, get as h, HTTPParser as i, STATUS_CODES as l, createServer as m, ClientRequest as n, METHODS as o, _default as p, ClientRequestArgs as r, ParsedHead as s, Agent as t, Server as u, request as v };