@warlock.js/core 4.0.174 → 4.1.3

package/esm/http/middleware/utils/parse-size.mjs

@@ -0,0 +1,32 @@
+//#region ../../@warlock.js/core/src/http/middleware/utils/parse-size.ts
+/**
+* Parse a human-readable size string into bytes.
+*
+* Accepts `"2mb"`, `"500kb"`, `"1.5gb"`, `"1024"`, `"1024b"`, etc. Case-insensitive.
+* Numeric input is returned untouched (already bytes).
+*
+* @example
+* parseSize("2mb");     // 2_097_152
+* parseSize("500kb");   // 512_000
+* parseSize(4096);      // 4096
+*/
+const UNITS = {
+	b: 1,
+	kb: 1024,
+	mb: 1024 * 1024,
+	gb: 1024 * 1024 * 1024
+};
+function parseSize(value) {
+	if (typeof value === "number") return value;
+	const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(value.trim());
+	if (!match) throw new Error(`Invalid size value: ${value}`);
+	const [, amount, rawUnit = "b"] = match;
+	const unit = rawUnit.toLowerCase();
+	const multiplier = UNITS[unit];
+	if (!multiplier) throw new Error(`Unknown size unit: ${unit}`);
+	return Math.floor(Number(amount) * multiplier);
+}
+
+//#endregion
+export { parseSize };
+//# sourceMappingURL=parse-size.mjs.map

package/esm/http/middleware/utils/parse-size.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-size.mjs","names":[],"sources":["../../../../../../../../@warlock.js/core/src/http/middleware/utils/parse-size.ts"],"sourcesContent":["/**\n * Parse a human-readable size string into bytes.\n *\n * Accepts `\"2mb\"`, `\"500kb\"`, `\"1.5gb\"`, `\"1024\"`, `\"1024b\"`, etc. Case-insensitive.\n * Numeric input is returned untouched (already bytes).\n *\n * @example\n * parseSize(\"2mb\");     // 2_097_152\n * parseSize(\"500kb\");   // 512_000\n * parseSize(4096);      // 4096\n */\nconst UNITS: Record<string, number> = {\n  b: 1,\n  kb: 1024,\n  mb: 1024 * 1024,\n  gb: 1024 * 1024 * 1024,\n};\n\nexport function parseSize(value: string | number): number {\n  if (typeof value === \"number\") {\n    return value;\n  }\n\n  const match = /^(\\d+(?:\\.\\d+)?)\\s*(b|kb|mb|gb)?$/i.exec(value.trim());\n\n  if (!match) {\n    throw new Error(`Invalid size value: ${value}`);\n  }\n\n  const [, amount, rawUnit = \"b\"] = match;\n  const unit = rawUnit.toLowerCase();\n  const multiplier = UNITS[unit];\n\n  if (!multiplier) {\n    throw new Error(`Unknown size unit: ${unit}`);\n  }\n\n  return Math.floor(Number(amount) * multiplier);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,QAAgC;CACpC,GAAG;CACH,IAAI;CACJ,IAAI,OAAO;CACX,IAAI,OAAO,OAAO;AACpB;AAEA,SAAgB,UAAU,OAAgC;CACxD,IAAI,OAAO,UAAU,UACnB,OAAO;CAGT,MAAM,QAAQ,qCAAqC,KAAK,MAAM,KAAK,CAAC;CAEpE,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,uBAAuB,OAAO;CAGhD,MAAM,GAAG,QAAQ,UAAU,OAAO;CAClC,MAAM,OAAO,QAAQ,YAAY;CACjC,MAAM,aAAa,MAAM;CAEzB,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,sBAAsB,MAAM;CAG9C,OAAO,KAAK,MAAM,OAAO,MAAM,IAAI,UAAU;AAC/C"}

package/esm/http/plugins.d.mts

@@ -0,0 +1,7 @@
+import { FastifyInstance } from "./server.mjs";
+
+//#region ../../@warlock.js/core/src/http/plugins.d.ts
+declare function registerHttpPlugins(server: FastifyInstance): Promise<void>;
+//#endregion
+export { registerHttpPlugins };
+//# sourceMappingURL=plugins.d.mts.map

package/esm/http/plugins.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/http/plugins.ts"],"mappings":";;;iBAWsB,mBAAA,CAAoB,MAAA,EAAQ,eAAA,GAAe,OAAA"}

package/esm/http/plugins.mjs

@@ -0,0 +1,37 @@
+import { rootPath } from "../utils/paths.mjs";
+import "../utils/index.mjs";
+import config from "@mongez/config";
+import fastifyMultipart from "@fastify/multipart";
+
+//#region ../../@warlock.js/core/src/http/plugins.ts
+const defaultCorsOptions = {
+	origin: "*",
+	methods: "*"
+};
+async function registerHttpPlugins(server) {
+	server.register(import("@fastify/rate-limit"), {
+		max: config.get("http.rateLimit.max", 60),
+		timeWindow: config.get("http.rateLimit.duration", 60 * 1e3)
+	});
+	const corsOptions = {
+		...config.get("http.cors", {}),
+		...defaultCorsOptions
+	};
+	server.register(import("@fastify/cors"), corsOptions);
+	server.register(fastifyMultipart, {
+		attachFieldsToBody: true,
+		limits: { fileSize: config.get("http.fileUploadLimit", 10 * 1024 * 1024) }
+	});
+	server.register(import("@fastify/static"), {
+		root: config.get("storage.publicRoot", rootPath("public")),
+		prefix: config.get("storage.publicPrefix", "/public/")
+	});
+	server.register(import("@fastify/cookie"), {
+		secret: config.get("http.cookies.secret"),
+		parseOptions: config.get("http.cookies.options", {})
+	});
+}
+
+//#endregion
+export { registerHttpPlugins };
+//# sourceMappingURL=plugins.mjs.map

package/esm/http/plugins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/http/plugins.ts"],"sourcesContent":["import type { FastifyCorsOptions } from \"@fastify/cors\";\nimport fastifyMultipart from \"@fastify/multipart\";\nimport config from \"@mongez/config\";\nimport { rootPath } from \"../utils\";\nimport type { FastifyInstance } from \"./server\";\n\nconst defaultCorsOptions: FastifyCorsOptions = {\n  origin: \"*\",\n  methods: \"*\",\n};\n\nexport async function registerHttpPlugins(server: FastifyInstance) {\n  // 👇🏻 register rate-limit plugin\n  server.register(import(\"@fastify/rate-limit\"), {\n    // max requests per time window\n    max: config.get(\"http.rateLimit.max\", 60),\n    // maximum time that is will allow max requests\n    timeWindow: config.get(\"http.rateLimit.duration\", 60 * 1000),\n  });\n\n  // 👇🏻 register cors plugin\n  const corsOptions: FastifyCorsOptions | undefined = {\n    ...config.get(\"http.cors\", {}),\n    ...defaultCorsOptions,\n  };\n\n  server.register(import(\"@fastify/cors\"), corsOptions);\n\n  // 👇🏻 import multipart plugin\n  server.register(fastifyMultipart, {\n    attachFieldsToBody: true,\n    limits: {\n      // file size could be up to 10MB\n      fileSize: config.get(\"http.fileUploadLimit\", 10 * 1024 * 1024),\n    },\n  });\n\n  server.register(import(\"@fastify/static\"), {\n    root: config.get(\"storage.publicRoot\", rootPath(\"public\")),\n    prefix: config.get(\"storage.publicPrefix\", \"/public/\"),\n  });\n\n  // 👇🏻 register cookie plugin\n  server.register(import(\"@fastify/cookie\"), {\n    secret: config.get(\"http.cookies.secret\"), // Optional: allow signed cookies\n    parseOptions: config.get(\"http.cookies.options\", {}),\n  });\n}\n"],"mappings":";;;;;;AAMA,MAAM,qBAAyC;CAC7C,QAAQ;CACR,SAAS;AACX;AAEA,eAAsB,oBAAoB,QAAyB;CAEjE,OAAO,SAAS,OAAO,wBAAwB;EAE7C,KAAK,OAAO,IAAI,sBAAsB,EAAE;EAExC,YAAY,OAAO,IAAI,2BAA2B,KAAK,GAAI;CAC7D,CAAC;CAGD,MAAM,cAA8C;EAClD,GAAG,OAAO,IAAI,aAAa,CAAC,CAAC;EAC7B,GAAG;CACL;CAEA,OAAO,SAAS,OAAO,kBAAkB,WAAW;CAGpD,OAAO,SAAS,kBAAkB;EAChC,oBAAoB;EACpB,QAAQ,EAEN,UAAU,OAAO,IAAI,wBAAwB,KAAK,OAAO,IAAI,EAC/D;CACF,CAAC;CAED,OAAO,SAAS,OAAO,oBAAoB;EACzC,MAAM,OAAO,IAAI,sBAAsB,SAAS,QAAQ,CAAC;EACzD,QAAQ,OAAO,IAAI,wBAAwB,UAAU;CACvD,CAAC;CAGD,OAAO,SAAS,OAAO,oBAAoB;EACzC,QAAQ,OAAO,IAAI,qBAAqB;EACxC,cAAc,OAAO,IAAI,wBAAwB,CAAC,CAAC;CACrD,CAAC;AACH"}

package/esm/http/request-controller.d.mts

@@ -0,0 +1,15 @@
+import { Request } from "./request.mjs";
+import { Response } from "./response.mjs";
+import { ReturnedResponse } from "./types.mjs";
+import { RequestControllerContract } from "../router/types.mjs";
+
+//#region ../../@warlock.js/core/src/http/request-controller.d.ts
+declare abstract class RequestController implements RequestControllerContract {
+  readonly request: Request;
+  readonly response: Response;
+  constructor(request: Request, response: Response);
+  abstract execute(): Promise<ReturnedResponse>;
+}
+//#endregion
+export { RequestController };
+//# sourceMappingURL=request-controller.d.mts.map

package/esm/http/request-controller.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-controller.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/http/request-controller.ts"],"mappings":";;;;;;uBAKsB,iBAAA,YAA6B,yBAAA;EAAA,SAE/B,OAAA,EAAS,OAAA;EAAA,SACT,QAAA,EAAU,QAAA;cADV,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,QAAA;EAAA,SAKZ,OAAA,CAAA,GAAW,OAAA,CAAQ,gBAAA;AAAA"}

package/esm/http/request-controller.mjs

@@ -0,0 +1,11 @@
+//#region ../../@warlock.js/core/src/http/request-controller.ts
+var RequestController = class {
+	constructor(request, response) {
+		this.request = request;
+		this.response = response;
+	}
+};
+
+//#endregion
+export { RequestController };
+//# sourceMappingURL=request-controller.mjs.map

package/esm/http/request-controller.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-controller.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/http/request-controller.ts"],"sourcesContent":["import type { RequestControllerContract } from \"./../router/types\";\nimport type { Request } from \"./request\";\nimport type { Response } from \"./response\";\nimport type { ReturnedResponse } from \"./types\";\n\nexport abstract class RequestController implements RequestControllerContract {\n  public constructor(\n    public readonly request: Request,\n    public readonly response: Response,\n  ) {\n    //\n  }\n\n  public abstract execute(): Promise<ReturnedResponse>;\n}\n"],"mappings":";AAKA,IAAsB,oBAAtB,MAA6E;CAC3E,AAAO,YACL,AAAgB,SAChB,AAAgB,UAChB;EAFgB;EACA;CAGlB;AAGF"}

package/esm/http/request.d.mts

@@ -0,0 +1,458 @@
+import { UploadedFile } from "./uploaded-file.mjs";
+import { Response } from "./response.mjs";
+import { RequestEvent } from "./types.mjs";
+import { Middleware, RequestHandler, Route } from "../router/types.mjs";
+import { BaseValidator } from "@warlock.js/seal";
+import { trans } from "@mongez/localization";
+import { LogLevel } from "@warlock.js/logger";
+import { FastifyRequest } from "fastify";
+import { IncomingHttpHeaders } from "node:http2";
+
+//#region ../../@warlock.js/core/src/http/request.d.ts
+type StandardHeaders = { [K in keyof IncomingHttpHeaders as string extends K ? never : number extends K ? never : K]: IncomingHttpHeaders[K] };
+type HeaderKeys = keyof StandardHeaders;
+declare class Request<RequestValidation = any> {
+  /**
+   * Underlying Fastify request — a public escape hatch to capabilities the
+   * framework's high-level helpers don't yet cover.
+   *
+   * **Prefer framework methods first**: `request.input()`, `request.header()`,
+   * `request.body`, `request.query`, `request.params`, `request.file()`,
+   * `request.user`, `request.detectIp()`, etc. They handle locale, parsing,
+   * trust-proxy, and validation pipeline integration correctly.
+   *
+   * **Reach for `baseRequest` only** when the framework genuinely lacks a
+   * helper for what you need — and when you do, file an issue so we can add
+   * it. The escape hatch is the release valve that lets consumers move
+   * faster than the framework, but every long-term reach here is a missing
+   * helper waiting to be added.
+   */
+  baseRequest: FastifyRequest;
+  /**
+   * Response Object
+   */
+  response: Response;
+  /**
+   * Route Object
+   */
+  route: Route;
+  /**
+   * Parsed Request Payload
+   */
+  protected payload: any;
+  /**
+   * Decoded access token payload (set by auth middleware)
+   */
+  decodedAccessToken?: any;
+  /**
+   * Current request instance
+   */
+  static current: Request;
+  /**
+   * Translation method
+   * Type of it is the same as the type of trans function
+   */
+  trans: ReturnType<typeof trans>;
+  /**
+   * Alias to trans method
+   */
+  t: ReturnType<typeof trans>;
+  /**
+   * Dynamic properties index signature
+   *
+   * This allows attaching custom properties to the request instance,
+   * commonly used during validation middleware to attach fetched models.
+   *
+   * @example
+   * // In validation middleware:
+   * const post = await Post.find(request.int("id"));
+   * if (!post) return response.notFound();
+   * request.post = post; // Attach the model to the request
+   *
+   * // In route handler:
+   * const post = request.post;
+   * // Work with the pre-fetched model
+   */
+  [key: string]: any;
+  /**
+   * Locale code
+   */
+  protected _locale: string;
+  /**
+   * Validated data
+   */
+  protected validatedData?: RequestValidation;
+  /**
+   * Request id
+   */
+  id: string;
+  /**
+   * Start Time
+   */
+  startTime: number;
+  /**
+   * End Time
+   */
+  endTime?: undefined | number;
+  /**
+   * Set request handler
+   */
+  setRequest(request: FastifyRequest): this;
+  /**
+   * Inherit `X-Request-Id` from the incoming request, fall back to a custom
+   * generator, then to the field-init default (`Random.string(32)`).
+   *
+   * Inherited values are validated (length cap + printable-ASCII) to prevent
+   * log-injection from a malicious client. Disable the whole behavior by
+   * setting `http.requestId.enabled = false` — in which case the field-init
+   * default is used regardless of any incoming header.
+   */
+  protected resolveRequestId(): void;
+  /**
+   * Validate a candidate request-id value. Accepts non-empty printable ASCII
+   * up to 128 characters — tight enough to reject newline / control-character
+   * log-injection, loose enough to accept UUIDs, ULIDs, snowflakes, etc.
+   */
+  protected static isValidRequestId(value: unknown): value is string;
+  /**
+   * Translate from the given locale code
+   */
+  transFrom(localeCode: string, keyword: string, placeholders?: any): any;
+  /**
+   * Get current locale code
+   */
+  get locale(): string;
+  /**
+   * Set locale code
+   */
+  set locale(localeCode: string);
+  /**
+   * Get locale code that will be used for translation
+   */
+  get localized(): any;
+  /**
+   * Set locale code
+   */
+  setLocaleCode(localeCode: string): this;
+  /**
+   * Get current locale code or return default locale code
+   */
+  getLocaleCode(defaultLocaleCode?: string): string;
+  /**
+   * Get http protocol
+   */
+  get protocol(): "http" | "https";
+  /**
+   * Validate the given validation schema
+   */
+  validate(validation: BaseValidator, selectedInputs?: string[]): Promise<any>;
+  /**
+   * Clear current user
+   */
+  clearCurrentUser(): void;
+  /**
+   * Get value of the given header
+   */
+  header<TCustomHeader extends string = HeaderKeys>(name: TCustomHeader | HeaderKeys, defaultValue?: any): any;
+  /**
+   * Get all cookies from the current request
+   */
+  get cookies(): Record<string, string | undefined>;
+  /**
+   * Get a particular cookie value or fallback to default
+   */
+  cookie(name: string, defaultValue?: any): string | any;
+  /**
+   * Determine if the request has the specified cookie
+   */
+  hasCookie(name: string): boolean;
+  /**
+   * Get the current request domain
+   */
+  get domain(): string;
+  /**
+   * Get hostname
+   */
+  get hostname(): string;
+  /**
+   * Get request origin
+   */
+  get origin(): string;
+  /**
+   * Get the domain of the origin
+   */
+  get originDomain(): string | null;
+  /**
+   * Get authorization header value
+   */
+  get authorizationValue(): string;
+  /**
+   * Get access token from Authorization header
+   *
+   * If the Authorization header does not start with `Bearer` value then return null
+   */
+  get accessToken(): string | undefined;
+  /**
+   * Get the authorization header
+   */
+  get authorization(): any;
+  /**
+   * Get current request method
+   */
+  get method(): string;
+  /**
+   * Parse the payload and merge it from the request body, params and query string
+   */
+  protected parsePayload(): void;
+  /**
+   * Parse body payload
+   */
+  protected parseBody(data: any): any;
+  /**
+   * Parse the given data
+   */
+  protected parseValue(data: any): any;
+  /**
+   * Set route handler
+   */
+  setRoute(route: Route): this;
+  /**
+   * Trigger an http event
+   */
+  trigger(eventName: RequestEvent, ...args: any[]): any;
+  /**
+   * Listen to the given event
+   */
+  on(eventName: RequestEvent, callback: any): any;
+  /**
+   * Make a log message
+   */
+  log(message: any, level?: LogLevel): void;
+  /**
+   * Get current request path
+   */
+  get path(): string;
+  /**
+   * {@alias}
+   */
+  get url(): string;
+  /**
+   * Get full url
+   */
+  get fullUrl(): string;
+  /**
+   * Drive the middleware chain for the current route, then defer to the
+   * controller. Returns the first response value any middleware short-circuits
+   * with, or `undefined` to continue into validation + handler.
+   *
+   * @internal Framework orchestration — do not call from app code. Will move
+   * to a dedicated controller dispatcher in a future refactor.
+   */
+  runMiddleware(): Promise<any[] | Record<string, any> | Response | undefined>;
+  /**
+   * Return the request handler attached to the current route.
+   *
+   * @internal Framework orchestration — do not call from app code.
+   */
+  getHandler(): RequestHandler<Request<any>>;
+  /**
+   * Get inputs that has been validated only
+   * You can also pass an array of inputs to get only the validated inputs
+   */
+  validated<Output = RequestValidation>(inputs?: (keyof Output | (string & {}))[]): Output;
+  /**
+   * Get inputs that has been validated except the given inputs
+   */
+  validatedExcept(...inputs: string[]): RequestValidation;
+  /**
+   * Set validated data
+   */
+  setValidatedData(data: RequestValidation): void;
+  /**
+   * Top-level entry into the request lifecycle — opens the context store,
+   * runs middleware, drives the handler, handles errors.
+   *
+   * @internal Framework orchestration — do not call from app code. Wired
+   * from the Fastify route handler in `router.scan()`.
+   */
+  execute(): Promise<any[] | Record<string, any> | Response>;
+  /**
+   * Iterate the collected middlewares in order; return the first short-circuit
+   * value or `undefined` when every middleware passes through.
+   *
+   * @internal Framework orchestration — do not call from app code.
+   */
+  protected executeMiddleware(): Promise<any[] | Record<string, any> | Response | undefined>;
+  /**
+   * Gather the middleware list for the current route — today just the
+   * route-level array; future extraction may merge group + app-wide layers.
+   *
+   * @internal Framework orchestration — do not call from app code.
+   */
+  protected collectMiddlewares(): Middleware[];
+  /**
+   * Get request input value from query string, params or body
+   */
+  input(key: string, defaultValue?: any): any;
+  /**
+   * Get email input value, this will lowercase the value
+   */
+  email(key?: string, defaultValue?: string): string;
+  /**
+   * @alias input
+   */
+  get(key: string, defaultValue?: any): any;
+  /**
+   * Determine if request has input value
+   */
+  has(key: string): boolean;
+  /**
+   * Set request input value
+   */
+  set(key: string, value: any): this;
+  /**
+   * Set the given value if the request does not have the input
+   */
+  setDefault(key: string, value: any): this;
+  /**
+   * Unset request payload keys
+   */
+  unset(...keys: string[]): this;
+  /**
+   * Get request body
+   */
+  get body(): any;
+  /**
+   * Set request body value
+   */
+  setBody(key: string, value: any): this;
+  /**
+   * Get body inputs except files
+   */
+  get bodyInputs(): any;
+  /**
+   * Get request file in UploadedFile instance
+   */
+  file(key: string): UploadedFile | undefined;
+  /**
+   * Get uploaded files from the request for the given name
+   * If the given name is not present in the request, return an empty array
+   */
+  files(name: string): UploadedFile[];
+  /**
+   * Get request params
+   */
+  get params(): any;
+  /**
+   * Set request params value
+   */
+  setParam(key: string, value: any): this;
+  /**
+   * Get request query
+   */
+  get query(): any;
+  /**
+   * Set request query value
+   */
+  setQuery(key: string, value: any): this;
+  /**
+   * Get all inputs
+   */
+  all(): any;
+  /**
+   * Get all inputs except params
+   */
+  allExceptParams(): any;
+  /**
+   * Get all heavy inputs except params
+   */
+  heavyExceptParams(): any;
+  /**
+   * Get only heavy inputs, the input with a value
+   */
+  heavy(): any;
+  /**
+   * Get only the given keys from the request data
+   */
+  only(keys: string[]): any;
+  /**
+   * Pluck the given keys from the request data
+   */
+  pluck(keys: string[]): any;
+  /**
+   * Get all request inputs except the given keys
+   */
+  except(keys: string[]): any;
+  /**
+   * Get boolean input value
+   */
+  bool(key: string, defaultValue?: boolean): boolean;
+  /**
+   * Get integer input value
+   */
+  int(key: string, defaultValue?: number): number | undefined;
+  /**
+   * Shorthand getter to get id param
+   */
+  get idParam(): number | undefined;
+  /**
+   * Get string input value
+   */
+  string(key: string, defaultValue?: string): string;
+  /**
+   * Get float input value
+   */
+  float(key: string, defaultValue?: number): number;
+  /**
+   * Get number input value
+   */
+  number(key: string, defaultValue?: number): number;
+  /**
+   * Immediate-peer IP as Fastify reports it — the address that connected to
+   * the server socket, with `trustProxy` resolution applied. Use this when
+   * you specifically need the peer address (rate-limit-by-direct-connection,
+   * health-check origin verification).
+   *
+   * **For most use cases prefer `request.detectIp()`** — behind any proxy
+   * (load balancer, CDN, sidecar) `ip` reports the proxy, not the real client.
+   */
+  get ip(): string;
+  /**
+   * Best-effort real client IP — checks `X-Real-IP` and `X-Forwarded-For`
+   * headers first, falls back to `baseRequest.ip` when neither is present.
+   *
+   * **Prefer this over `request.ip` for any caller behind a proxy** (load
+   * balancer, CDN, reverse proxy, k8s ingress). Only trust the result as
+   * far as you trust the upstream proxy chain — `X-Forwarded-For` is
+   * client-settable; verify the request came through your trusted edge
+   * before treating the value as authoritative.
+   */
+  detectIp(): any;
+  /**
+   * An alias to detectIp
+   */
+  get realIp(): any;
+  /**
+   * Get request ips
+   */
+  get ips(): string[] | undefined;
+  /**
+   * Get request referer
+   */
+  get referer(): string | undefined;
+  /**
+   * Get user agent
+   */
+  get userAgent(): string | undefined;
+  /**
+   * Get request headers
+   */
+  get headers(): typeof this.baseRequest.headers;
+  /**
+   * Set the given header
+   */
+  setHeader(key: HeaderKeys, value: string): this;
+}
+//#endregion
+export { Request };
+//# sourceMappingURL=request.d.mts.map

package/esm/http/request.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/http/request.ts"],"mappings":"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"}