npm - adorn-api - Versions diffs - 1.1.11 → 1.1.13 - Mend

adorn-api 1.1.11 → 1.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

package/README.md +18 -0
package/dist/adapter/express/types.d.ts +3 -46
package/dist/adapter/fastify/coercion.d.ts +12 -0
package/dist/adapter/fastify/coercion.js +289 -0
package/dist/adapter/fastify/controllers.d.ts +7 -0
package/dist/adapter/fastify/controllers.js +201 -0
package/dist/adapter/fastify/index.d.ts +14 -0
package/dist/adapter/fastify/index.js +67 -0
package/dist/adapter/fastify/multipart.d.ts +26 -0
package/dist/adapter/fastify/multipart.js +75 -0
package/dist/adapter/fastify/openapi.d.ts +10 -0
package/dist/adapter/fastify/openapi.js +76 -0
package/dist/adapter/fastify/response-serializer.d.ts +2 -0
package/dist/adapter/fastify/response-serializer.js +162 -0
package/dist/adapter/fastify/types.d.ts +100 -0
package/dist/adapter/fastify/types.js +2 -0
package/dist/adapter/metal-orm/index.d.ts +1 -1
package/dist/adapter/metal-orm/types.d.ts +23 -0
package/dist/adapter/native/coercion.d.ts +12 -0
package/dist/adapter/native/coercion.js +289 -0
package/dist/adapter/native/controllers.d.ts +17 -0
package/dist/adapter/native/controllers.js +215 -0
package/dist/adapter/native/index.d.ts +14 -0
package/dist/adapter/native/index.js +127 -0
package/dist/adapter/native/openapi.d.ts +7 -0
package/dist/adapter/native/openapi.js +82 -0
package/dist/adapter/native/response-serializer.d.ts +5 -0
package/dist/adapter/native/response-serializer.js +160 -0
package/dist/adapter/native/router.d.ts +25 -0
package/dist/adapter/native/router.js +68 -0
package/dist/adapter/native/types.d.ts +77 -0
package/dist/adapter/native/types.js +2 -0
package/dist/core/auth.d.ts +11 -12
package/dist/core/auth.js +2 -2
package/dist/core/logger.d.ts +3 -4
package/dist/core/logger.js +2 -2
package/dist/core/streaming.d.ts +10 -10
package/dist/core/streaming.js +31 -19
package/dist/core/types.d.ts +102 -0
package/dist/index.d.ts +6 -1
package/dist/index.js +16 -1
package/examples/fastify/app.ts +16 -0
package/examples/fastify/index.ts +21 -0
package/package.json +24 -18
package/src/adapter/express/controllers.ts +249 -249
package/src/adapter/express/types.ts +121 -160
package/src/adapter/fastify/coercion.ts +369 -0
package/src/adapter/fastify/controllers.ts +255 -0
package/src/adapter/fastify/index.ts +53 -0
package/src/adapter/fastify/multipart.ts +94 -0
package/src/adapter/fastify/openapi.ts +93 -0
package/src/adapter/fastify/response-serializer.ts +179 -0
package/src/adapter/fastify/types.ts +119 -0
package/src/adapter/metal-orm/index.ts +3 -0
package/src/adapter/metal-orm/types.ts +25 -0
package/src/adapter/native/coercion.ts +369 -0
package/src/adapter/native/controllers.ts +271 -0
package/src/adapter/native/index.ts +116 -0
package/src/adapter/native/openapi.ts +109 -0
package/src/adapter/native/response-serializer.ts +177 -0
package/src/adapter/native/router.ts +90 -0
package/src/adapter/native/types.ts +96 -0
package/src/core/auth.ts +314 -315
package/src/core/health.ts +234 -235
package/src/core/logger.ts +245 -247
package/src/core/streaming.ts +342 -330
package/src/core/types.ts +115 -0
package/src/index.ts +46 -16
package/tests/e2e/fastify.e2e.test.ts +174 -0
package/tests/native.test.ts +191 -0
package/tests/typecheck/query-params.typecheck.ts +42 -0
package/tests/unit/openapi-parameters.test.ts +97 -97
package/tsconfig.json +14 -13
package/tsconfig.typecheck.json +8 -0
package/vitest.config.ts +47 -7

package/dist/adapter/native/openapi.js ADDED Viewed

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOpenApi = registerOpenApi;
+const openapi_1 = require("../../core/openapi");
+/**
+ * Registers OpenAPI endpoints with a native application router.
+ */
+function registerOpenApi(router, controllers, options) {
+    const openApiPath = normalizePath(options.path, "/openapi.json");
+    const document = (0, openapi_1.buildOpenApi)({
+        info: options.info,
+        servers: options.servers,
+        controllers
+    });
+    router.add({
+        getOpenApi: async () => {
+            return document;
+        }
+    }, {
+        handlerName: "getOpenApi",
+        httpMethod: "get",
+        path: openApiPath,
+        responses: [{ status: 200, description: "OpenAPI JSON" }]
+    }, "");
+    if (!options.docs) {
+        return;
+    }
+    const docsOptions = typeof options.docs === "object" ? options.docs : {};
+    const docsPath = normalizePath(docsOptions.path, "/docs");
+    const title = docsOptions.title ?? `${options.info.title} Docs`;
+    const swaggerUiUrl = (docsOptions.swaggerUiUrl ?? "https://unpkg.com/swagger-ui-dist@5").replace(/\/+$/, "");
+    const html = buildSwaggerUiHtml({ title, swaggerUiUrl, openApiPath });
+    router.add({
+        getDocs: async () => {
+            return html;
+        }
+    }, {
+        handlerName: "getDocs",
+        httpMethod: "get",
+        path: docsPath,
+        raw: true,
+        responses: [{ status: 200, contentType: "text/html", description: "Swagger UI" }]
+    }, "");
+}
+function normalizePath(path, fallback) {
+    if (!path) {
+        return fallback;
+    }
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function buildSwaggerUiHtml(options) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>${options.title}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="stylesheet" href="${options.swaggerUiUrl}/swagger-ui.css" />
+    <style>
+      body {
+        margin: 0;
+        background: #f6f6f6;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="${options.swaggerUiUrl}/swagger-ui-bundle.js"></script>
+    <script>
+      window.onload = () => {
+        window.ui = SwaggerUIBundle({
+          url: "${options.openApiPath}",
+          dom_id: "#swagger-ui",
+          deepLinking: true,
+          presets: [SwaggerUIBundle.presets.apis],
+          layout: "BaseLayout"
+        });
+      };
+    </script>
+  </body>
+</html>`;
+}

package/dist/adapter/native/response-serializer.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { SchemaSource } from "../../core/schema";
+/**
+ * Serializes a response body based on the provided schema.
+ */
+export declare function serializeResponse(value: unknown, schema: SchemaSource): unknown;

package/dist/adapter/native/response-serializer.js ADDED Viewed

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeResponse = serializeResponse;
+const metadata_1 = require("../../core/metadata");
+/**
+ * Serializes a response body based on the provided schema.
+ */
+function serializeResponse(value, schema) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (isSchemaNode(schema)) {
+        return serializeWithSchema(value, schema);
+    }
+    return serializeWithDto(value, schema);
+}
+function serializeWithDto(value, dto) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => serializeWithDto(entry, dto));
+    }
+    const plainValue = toPlainObject(value);
+    if (!plainValue) {
+        return value;
+    }
+    const meta = (0, metadata_1.getDtoMeta)(dto);
+    if (!meta) {
+        return plainValue;
+    }
+    const output = { ...plainValue };
+    for (const [name, field] of Object.entries(meta.fields)) {
+        if (name in plainValue) {
+            output[name] = serializeWithSchema(plainValue[name], field.schema);
+        }
+    }
+    return output;
+}
+function serializeWithSchema(value, schema) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (schema.kind) {
+        case "string":
+            return serializeString(value, schema.format);
+        case "array":
+            if (!Array.isArray(value)) {
+                return value;
+            }
+            return value.map((entry) => serializeWithSchema(entry, schema.items));
+        case "object":
+            return serializeObject(value, schema.properties);
+        case "record":
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            return serializeRecord(value, schema.values);
+        case "ref":
+            return serializeWithDto(value, schema.dto);
+        case "union":
+            return serializeUnion(value, schema.anyOf);
+        default:
+            return value;
+    }
+}
+function serializeString(value, format) {
+    if (format === "byte" && Buffer.isBuffer(value)) {
+        return value.toString("base64");
+    }
+    if (!(value instanceof Date)) {
+        return value;
+    }
+    if (Number.isNaN(value.getTime())) {
+        return value;
+    }
+    if (format === "date") {
+        return value.toISOString().slice(0, 10);
+    }
+    if (format === "date-time") {
+        return value.toISOString();
+    }
+    return value;
+}
+function serializeObject(value, properties) {
+    const plainValue = toPlainObject(value);
+    if (!plainValue) {
+        return value;
+    }
+    const output = { ...plainValue };
+    if (!properties) {
+        return output;
+    }
+    for (const [key, schema] of Object.entries(properties)) {
+        if (key in plainValue) {
+            output[key] = serializeWithSchema(plainValue[key], schema);
+        }
+    }
+    return output;
+}
+function serializeRecord(value, schema) {
+    const output = { ...value };
+    for (const [key, entry] of Object.entries(value)) {
+        output[key] = serializeWithSchema(entry, schema);
+    }
+    return output;
+}
+function serializeUnion(value, options) {
+    for (const option of options) {
+        const serialized = serializeWithSchema(value, option);
+        if (serialized !== value) {
+            return serialized;
+        }
+    }
+    return value;
+}
+function isSchemaNode(value) {
+    return !!value && typeof value === "object" && "kind" in value;
+}
+function isPlainObject(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !(value instanceof Date));
+}
+function toPlainObject(value) {
+    if (value !== null &&
+        typeof value === "object" &&
+        typeof value.toJSON === "function") {
+        const jsonResult = value.toJSON();
+        return jsonResult;
+    }
+    if (typeof value === "object" && typeof value.load === "function") {
+        const wrapper = value;
+        if (wrapper.current !== undefined && wrapper.current !== null) {
+            return toPlainObject(wrapper.current);
+        }
+        if (wrapper.loaded) {
+            return null;
+        }
+        return null;
+    }
+    if (isPlainObject(value)) {
+        return value;
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const key of Object.getOwnPropertyNames(value)) {
+            if (key.startsWith('_') || key === 'constructor' || key === 'prototype')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor && descriptor.enumerable) {
+                const propertyValue = value[key];
+                result[key] = propertyValue;
+            }
+        }
+        return result;
+    }
+    return null;
+}

package/dist/adapter/native/router.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { RouteMeta } from "../../core/metadata";
+/**
+ * Result of a route match.
+ */
+export interface RouteMatch {
+    controller: any;
+    route: RouteMeta;
+    params: Record<string, string>;
+}
+/**
+ * A simple router for matching URL paths to routes.
+ */
+export declare class Router {
+    private routes;
+    /**
+     * Registers a route in the router.
+     */
+    add(controller: any, route: RouteMeta, basePath: string): void;
+    /**
+     * Matches an incoming request to a registered route.
+     */
+    match(method: string, path: string): RouteMatch | undefined;
+    private joinPaths;
+    private compilePath;
+}

package/dist/adapter/native/router.js ADDED Viewed

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+/**
+ * A simple router for matching URL paths to routes.
+ */
+class Router {
+    routes = [];
+    /**
+     * Registers a route in the router.
+     */
+    add(controller, route, basePath) {
+        const fullPath = this.joinPaths(basePath, route.path);
+        const { pattern, paramNames } = this.compilePath(fullPath);
+        this.routes.push({
+            method: route.httpMethod,
+            pattern,
+            paramNames,
+            controller,
+            route
+        });
+    }
+    /**
+     * Matches an incoming request to a registered route.
+     */
+    match(method, path) {
+        const normalizedMethod = method.toLowerCase();
+        const url = new URL(path, "http://localhost");
+        const pathname = url.pathname;
+        for (const entry of this.routes) {
+            if (entry.method !== normalizedMethod) {
+                continue;
+            }
+            const match = entry.pattern.exec(pathname);
+            if (match) {
+                const params = {};
+                for (let i = 0; i < entry.paramNames.length; i++) {
+                    params[entry.paramNames[i]] = decodeURIComponent(match[i + 1]);
+                }
+                return {
+                    controller: entry.controller,
+                    route: entry.route,
+                    params
+                };
+            }
+        }
+        return undefined;
+    }
+    joinPaths(base, path) {
+        const normalizedBase = base.replace(/\/+$/, "");
+        const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+        return `${normalizedBase}${normalizedPath}` || "/";
+    }
+    compilePath(path) {
+        const paramNames = [];
+        const patternStr = path
+            .replace(/:([a-zA-Z0-9_]+)/g, (_, name) => {
+            paramNames.push(name);
+            return "([^/]+)";
+        })
+            .replace(/\//g, "\\/");
+        return {
+            pattern: new RegExp(`^${patternStr}$`),
+            paramNames
+        };
+    }
+}
+exports.Router = Router;

package/dist/adapter/native/types.d.ts ADDED Viewed

@@ -0,0 +1,77 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Constructor, RequestContext as CoreRequestContext, UploadedFileInfo } from "../../core/types";
+import type { OpenApiInfo, OpenApiServer } from "../../core/openapi";
+export { UploadedFileInfo };
+/**
+ * Request context provided to native route handlers.
+ */
+export type RequestContext<TBody = any, TQuery extends object | undefined = Record<string, any>, TParams extends object | undefined = Record<string, any>, THeaders extends object | undefined = Record<string, any>, TFiles extends Record<string, UploadedFileInfo | UploadedFileInfo[]> | undefined = any> = CoreRequestContext<TBody, TQuery, TParams, THeaders, TFiles>;
+/**
+ * Input coercion modes.
+ */
+export type InputCoercionMode = "safe" | "strict";
+/**
+ * Input coercion setting - can be a mode or disabled.
+ */
+export type InputCoercionSetting = InputCoercionMode | false;
+/**
+ * Options for OpenAPI documentation UI.
+ */
+export interface OpenApiDocsOptions {
+    /** Path for documentation UI */
+    path?: string;
+    /** Title for documentation page */
+    title?: string;
+    /** URL for Swagger UI assets */
+    swaggerUiUrl?: string;
+}
+/**
+ * OpenAPI configuration for native adapter.
+ */
+export interface OpenApiNativeOptions {
+    /** OpenAPI document info */
+    info: OpenApiInfo;
+    /** Array of servers */
+    servers?: OpenApiServer[];
+    /** Path for OpenAPI JSON endpoint */
+    path?: string;
+    /** Whether to pretty-print the JSON output (defaults to false for minified output) */
+    prettyPrint?: boolean;
+    /** Documentation UI configuration */
+    docs?: boolean | OpenApiDocsOptions;
+}
+/**
+ * Validation configuration options.
+ */
+export interface ValidationOptions {
+    /** Whether validation is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Validation mode. 'strict' mode fails on any validation error, 'lax' mode may allow some errors. Defaults to 'strict'. */
+    mode?: "strict" | "lax";
+}
+/**
+ * Options for creating a native Node.js application adapter.
+ */
+export interface NativeAdapterOptions {
+    /** Array of controller classes */
+    controllers: Constructor[];
+    /** Whether to enable JSON body parsing */
+    jsonBody?: boolean;
+    /** Max JSON body size in bytes. */
+    bodyLimit?: number;
+    /** OpenAPI configuration */
+    openApi?: OpenApiNativeOptions;
+    /** Input coercion setting */
+    inputCoercion?: InputCoercionSetting;
+    /** Validation configuration. Set to false to disable validation, or provide options. */
+    validation?: boolean | ValidationOptions;
+}
+/**
+ * Interface for the native application.
+ */
+export interface NativeApp {
+    /** The native Node.js request handler */
+    handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    /** Start the server on the specified port */
+    listen(port: number, callback?: () => void): any;
+}

package/dist/adapter/native/types.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";
2	+ Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/auth.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import type { Request, Response, NextFunction } from "express";
 import type { Constructor } from "./types";
 /**
  * User context interface - extend this in your application.
@@ -17,12 +16,12 @@ export interface AuthOptions {
     /** All roles required (all must match) */
     allRoles?: string[];
     /** Custom guard function */
-    guard?: (user: AuthUser, req: Request) => boolean | Promise<boolean>;
+    guard?: (user: AuthUser, req: any) => boolean | Promise<boolean>;
 }
 /**
  * Function to extract user from request.
  */
-export type AuthExtractor = (req: Request) => AuthUser | null | Promise<AuthUser | null>;
+export type AuthExtractor = (req: any) => AuthUser | null | Promise<AuthUser | null>;
 /**
  * Options for creating auth middleware.
  */
@@ -32,9 +31,9 @@ export interface AuthMiddlewareOptions {
     /** Property name to attach user to request (default: "user") */
     userProperty?: string;
     /** Custom unauthorized response */
-    onUnauthorized?: (req: Request, res: Response) => void;
+    onUnauthorized?: (req: any, res: any) => void;
     /** Custom forbidden response */
-    onForbidden?: (req: Request, res: Response, reason?: string) => void;
+    onForbidden?: (req: any, res: any, reason?: string) => void;
 }
 /**
  * Metadata for authentication on routes/controllers.
@@ -49,7 +48,7 @@ interface AuthMeta {
     /** Required roles (all must match) */
     allRoles?: string[];
     /** Custom guard function */
-    guard?: (user: AuthUser, req: Request) => boolean | Promise<boolean>;
+    guard?: (user: AuthUser, req: any) => boolean | Promise<boolean>;
 }
 /**
  * Decorator to require authentication on a controller or route.
@@ -92,7 +91,7 @@ export declare function getControllerAuthMeta(controller: Constructor): AuthMeta
  * @param options - Auth middleware options
  * @returns Express middleware function
  */
-export declare function createAuthMiddleware(options: AuthMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare function createAuthMiddleware(options: AuthMiddlewareOptions): (req: any, res: any, next: (err?: any) => void) => Promise<void>;
 /**
  * Creates a route guard middleware that checks auth metadata.
  * @param controller - Controller class
@@ -102,20 +101,20 @@ export declare function createAuthMiddleware(options: AuthMiddlewareOptions): (r
  */
 export declare function createRouteGuard(controller: Constructor, handlerName: string | symbol, options?: {
     userProperty?: string;
-}): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}): (req: any, res: any, next: (err?: any) => void) => Promise<void>;
 /**
  * Helper to get user from request in controllers.
- * @param req - Express request
+ * @param req - Raw request
  * @param userProperty - Property name (default: "user")
  * @returns User or undefined
  */
-export declare function getUser<T extends AuthUser = AuthUser>(req: Request, userProperty?: string): T | undefined;
+export declare function getUser<T extends AuthUser = AuthUser>(req: any, userProperty?: string): T | undefined;
 /**
  * Helper to require user from request (throws if not present).
- * @param req - Express request
+ * @param req - Raw request
  * @param userProperty - Property name (default: "user")
  * @returns User
  * @throws HttpError if user not found
  */
-export declare function requireUser<T extends AuthUser = AuthUser>(req: Request, userProperty?: string): T;
+export declare function requireUser<T extends AuthUser = AuthUser>(req: any, userProperty?: string): T;
 export {};

package/dist/core/auth.js CHANGED Viewed

@@ -210,7 +210,7 @@ function createRouteGuard(controller, handlerName, options = {}) {
 }
 /**
  * Helper to get user from request in controllers.
- * @param req - Express request
+ * @param req - Raw request
  * @param userProperty - Property name (default: "user")
  * @returns User or undefined
  */
@@ -219,7 +219,7 @@ function getUser(req, userProperty = "user") {
 }
 /**
  * Helper to require user from request (throws if not present).
- * @param req - Express request
+ * @param req - Raw request
  * @param userProperty - Property name (default: "user")
  * @returns User
  * @throws HttpError if user not found

package/dist/core/logger.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import type { Request, Response, NextFunction } from "express";
 /**
  * Log levels in order of severity.
  */
@@ -45,13 +44,13 @@ export interface RequestLoggerOptions {
     /** Custom transport function (default: JSON to console) */
     transport?: LogTransport;
     /** Paths to skip logging (e.g., ["/health", "/health/live"]) */
-    skip?: string[] | ((req: Request) => boolean);
+    skip?: string[] | ((req: any) => boolean);
     /** Header name for request ID (default: "x-request-id") */
     requestIdHeader?: string;
     /** Whether to generate request ID if not present (default: true) */
     generateRequestId?: boolean;
     /** Custom context extractor */
-    context?: (req: Request, res: Response) => Record<string, unknown>;
+    context?: (req: any, res: any) => Record<string, unknown>;
 }
 /**
  * Logger interface for application-level logging.
@@ -99,7 +98,7 @@ export declare function prettyTransport(entry: RequestLogEntry | LogEntry): void
  * @param options - Logger configuration options
  * @returns Express middleware function
  */
-export declare function requestLogger(options?: RequestLoggerOptions): (req: Request, res: Response, next: NextFunction) => void;
+export declare function requestLogger(options?: RequestLoggerOptions): (req: any, res: any, next: (err?: any) => void) => void;
 /**
  * Creates a structured logger for application-level logging.
  * @param options - Logger configuration options

package/dist/core/logger.js CHANGED Viewed

@@ -85,7 +85,7 @@ function requestLogger(options = {}) {
         if (!requestId && generateRequestId) {
             requestId = generateId();
         }
-        if (requestId) {
+        if (requestId && res.setHeader) {
             res.setHeader(requestIdHeader, requestId);
         }
         const originalEnd = res.end;
@@ -102,7 +102,7 @@ function requestLogger(options = {}) {
                     url: req.originalUrl || req.url,
                     status: res.statusCode,
                     responseTime: Math.round(responseTime * 100) / 100,
-                    contentLength: res.get("content-length") ? parseInt(res.get("content-length"), 10) : undefined,
+                    contentLength: res.get ? parseInt(res.get("content-length"), 10) : undefined,
                     ip: req.ip || req.headers["x-forwarded-for"]?.split(",")[0]?.trim(),
                     userAgent: req.headers["user-agent"],
                     requestId,

package/dist/core/streaming.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { Response } from "express";
+import type { SseEmitterInterface, StreamWriterInterface } from "./types";
 /**
  * Server-Sent Event data structure.
  */
@@ -24,11 +24,11 @@ export interface SseEmitterOptions {
 /**
  * SSE Emitter for sending Server-Sent Events to clients.
  */
-export declare class SseEmitter {
+export declare class SseEmitter implements SseEmitterInterface {
     private readonly res;
     private closed;
     private keepAliveTimer?;
-    constructor(res: Response, options?: SseEmitterOptions);
+    constructor(res: any, options?: SseEmitterOptions);
     /**
      * Send an SSE event to the client.
      */
@@ -58,7 +58,7 @@ export declare class SseEmitter {
 /**
  * Create an SSE emitter from an Express response.
  */
-export declare function createSseEmitter(res: Response, options?: SseEmitterOptions): SseEmitter;
+export declare function createSseEmitter(res: any, options?: SseEmitterOptions): SseEmitter;
 /**
  * Options for streaming response configuration.
  */
@@ -71,10 +71,10 @@ export interface StreamOptions {
 /**
  * Stream writer for sending chunked data to clients.
  */
-export declare class StreamWriter {
+export declare class StreamWriter implements StreamWriterInterface {
     private readonly res;
     private closed;
-    constructor(res: Response, options?: StreamOptions);
+    constructor(res: any, options?: StreamOptions);
     /**
      * Write data to the stream.
      */
@@ -104,20 +104,20 @@ export declare class StreamWriter {
 /**
  * Create a stream writer from an Express response.
  */
-export declare function createStreamWriter(res: Response, options?: StreamOptions): StreamWriter;
+export declare function createStreamWriter(res: any, options?: StreamOptions): StreamWriter;
 /**
  * Create an NDJSON stream writer (newline-delimited JSON).
  */
-export declare function createNdjsonStream(res: Response): StreamWriter;
+export declare function createNdjsonStream(res: any): StreamWriter;
 /**
  * Stream an async iterable to the response.
  */
-export declare function streamIterable<T>(res: Response, iterable: AsyncIterable<T>, options?: StreamOptions & {
+export declare function streamIterable<T>(res: any, iterable: AsyncIterable<T>, options?: StreamOptions & {
     transform?: (item: T) => string | Buffer;
 }): Promise<void>;
 /**
  * Stream an async iterable as SSE events.
  */
-export declare function streamSseIterable<T>(res: Response, iterable: AsyncIterable<T>, options?: SseEmitterOptions & {
+export declare function streamSseIterable<T>(res: any, iterable: AsyncIterable<T>, options?: SseEmitterOptions & {
     eventType?: string;
 }): Promise<void>;