silgi 0.42.5 → 0.43.0

package/dist/core/orchestrate.mjs

@@ -0,0 +1,113 @@
+import { normalizeResult, useSilgi } from "./unctx.mjs";
+import { createError } from "./error.mjs";
+import { generateStorageKey, useSilgiStorage } from "./utils/storage.mjs";
+import { parseRequestInput } from "./utils/internal/req.mjs";
+import { getQuery, getRouterParams } from "./utils/request.mjs";
+import { getUrlPrefix } from "./utils/resolver.mjs";
+import { silgiFetch } from "./silgi.mjs";
+
+//#region src/core/orchestrate.ts
+async function orchestrate(route, event) {
+	const silgiCtx = useSilgi();
+	const silgiURL = getUrlPrefix(route.route || event.req.url, route.method);
+	const input = route.service?.rules?.readBeforeBody === false ? {} : await parseRequestInput(event.req);
+	const hookContext = { earlyReturnValue: false };
+	const routerParams = input.path || getRouterParams(event);
+	const queryParams = input.query || getQuery(event);
+	const inputData = {
+		args: input,
+		query: queryParams,
+		path: routerParams
+	};
+	try {
+		if (!route.service) throw createError({
+			statusCode: 404,
+			statusMessage: "Service not found"
+		});
+		const cachePromise = cacheExecute(input, route, silgiURL, event);
+		const beforeHookPromise = silgiCtx.callHook("fetch:before", {
+			url: silgiURL,
+			input,
+			event,
+			route,
+			hookContext
+		});
+		const cacheData = await cachePromise;
+		await beforeHookPromise;
+		if (hookContext.earlyReturnValue !== false) return hookContext.earlyReturnValue;
+		if (cacheData?.success) {
+			await silgiCtx.callHook("fetch:after", {
+				event,
+				url: silgiURL,
+				input,
+				result: cacheData.data,
+				success: true,
+				cached: true,
+				route,
+				hookContext
+			});
+			return cacheData.data;
+		}
+		silgiCtx.shared.$fetch = silgiFetch;
+		silgiCtx.shared.silgi = silgiCtx;
+		const result = await route.service?.handler?.(inputData, silgiCtx.shared, event);
+		await silgiCtx.callHook("fetch:after", {
+			event,
+			url: silgiURL,
+			input: inputData,
+			result,
+			success: true,
+			route,
+			hookContext
+		});
+		if (route.service?.storage && cacheData?.cachedKey) await useSilgiStorage(route.service.storage.base).setItem(cacheData.cachedKey, result, route.service.storage.options);
+		return result;
+	} catch (err) {
+		await silgiCtx.callHook("fetch:error", {
+			event,
+			input: inputData,
+			error: err instanceof Error ? err : new Error(String(err)),
+			url: silgiURL,
+			route,
+			hookContext
+		});
+		silgiCtx.captureError(silgiCtx, createError({
+			message: err instanceof Error ? err.message : String(err),
+			statusCode: 500,
+			statusMessage: "Internal Server Error",
+			cause: err
+		}), {
+			event,
+			tags: ["execute"]
+		});
+		throw err;
+	}
+}
+async function cacheExecute(input, route, silgiURL, event) {
+	if (!route.service || !route.service.storage) return;
+	const cacheKey = route.service.storage ? await generateStorageKey({
+		url: silgiURL,
+		input,
+		keyGenerator: route.service.storage.key,
+		storageOptions: route.service.storage,
+		requestId: event?.requestId
+	}) : null;
+	if (cacheKey) {
+		const cachedResult = await useSilgiStorage(route.service.storage.base).getItem(cacheKey);
+		if (cachedResult !== null) return {
+			success: true,
+			data: normalizeResult(cachedResult),
+			cached: true,
+			cachedKey: cacheKey
+		};
+	}
+	return {
+		success: false,
+		data: null,
+		cached: false,
+		cachedKey: cacheKey
+	};
+}
+
+//#endregion
+export { orchestrate };

package/dist/core/response.d.mts

@@ -0,0 +1,20 @@
+import { SilgiError$1 as SilgiError } from "./error.mjs";
+import { SilgiEvent } from "silgi/types";
+
+//#region src/core/response.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface SilgiHandlerConfig {
+  debug?: boolean;
+  // websocket?: WebSocketOptions;
+  onError?: (error: SilgiError, event: SilgiEvent) => MaybePromise<void | unknown>;
+  onRequest?: (event: SilgiEvent) => MaybePromise<void>;
+  onBeforeResponse?: (event: SilgiEvent, response: Response | PreparedResponse) => MaybePromise<void>;
+}
+type PreparedResponse = ResponseInit & {
+  body?: BodyInit | null;
+};
+declare const kNotFound: symbol;
+declare const kHandled: symbol;
+declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHandlerConfig): Response | Promise<Response>;
+//#endregion
+export { handleResponse as handleResponse$1, kHandled as kHandled$1, kNotFound as kNotFound$1 };

package/dist/core/response.mjs

@@ -0,0 +1,105 @@
+import { isJSONSerializable } from "./utils/internal/object.mjs";
+import { createError } from "./error.mjs";
+import { FastResponse } from "srvx";
+
+//#region src/core/response.ts
+const kNotFound = /* @__PURE__ */ Symbol.for("silgi.notFound");
+const kHandled = /* @__PURE__ */ Symbol.for("silgi.handled");
+function handleResponse(val, event, config) {
+	if (val && val instanceof Promise) return val.catch((error) => error).then((resolvedVal) => handleResponse(resolvedVal, event, config));
+	const response = prepareResponse(val, event, config);
+	if (response instanceof Promise) return handleResponse(response, event, config);
+	const { onBeforeResponse } = config;
+	return onBeforeResponse ? Promise.resolve(onBeforeResponse(event, response)).then(() => response) : response;
+}
+function prepareResponse(val, event, config, nested) {
+	if (val === kHandled) return new FastResponse(null);
+	if (val === kNotFound) val = createError({
+		statusCode: 404,
+		statusMessage: `Cannot find any route matching [${event.req.method}] ${event.url}`
+	});
+	if (val && val instanceof Error) {
+		const error = createError(val);
+		const { onError } = config;
+		return onError && !nested ? Promise.resolve(onError(error, event)).catch((error$1) => error$1).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+	}
+	const eventHeaders = event.res._headers;
+	if (!(val instanceof Response)) {
+		const res = prepareResponseBody(val, event, config);
+		const status = event.res.status;
+		return new FastResponse(nullBody(event.req.method, status) ? null : res.body, {
+			status,
+			statusText: event.res.statusText,
+			headers: res.headers && eventHeaders ? mergeHeaders(res.headers, eventHeaders) : res.headers || eventHeaders
+		});
+	}
+	if (!eventHeaders) return val;
+	return new FastResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+		status: val.status,
+		statusText: val.statusText,
+		headers: mergeHeaders(eventHeaders, val.headers)
+	});
+}
+function nullBody(method, status) {
+	return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function mergeHeaders(base, merge) {
+	const mergedHeaders = new Headers(base);
+	for (const [name, value] of merge) if (name === "set-cookie") mergedHeaders.append(name, value);
+	else mergedHeaders.set(name, value);
+	return mergedHeaders;
+}
+const emptyHeaders = new Headers({ "content-length": "0" });
+const jsonHeaders = new Headers({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+	if (val === null || val === void 0) return {
+		body: "",
+		headers: emptyHeaders
+	};
+	const valType = typeof val;
+	if (valType === "string") return { body: val };
+	if (val instanceof Uint8Array) {
+		event.res.headers.set("content-length", val.byteLength.toString());
+		return { body: val };
+	}
+	if (isJSONSerializable(val, valType)) return {
+		body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+		headers: jsonHeaders
+	};
+	if (valType === "bigint") return {
+		body: val.toString(),
+		headers: jsonHeaders
+	};
+	if (val instanceof Blob) {
+		const headers = {
+			"content-type": val.type,
+			"content-length": val.size.toString()
+		};
+		if ("name" in val) {
+			const filename = encodeURIComponent(val.name);
+			headers["content-disposition"] = `filename="${filename}"; filename*=UTF-8''${filename}`;
+		}
+		return {
+			body: val.stream(),
+			headers
+		};
+	}
+	if (valType === "symbol") return { body: val.toString() };
+	if (valType === "function") return { body: `${val.name}()` };
+	return { body: val };
+}
+function errorResponse(error, debug) {
+	return new FastResponse(JSON.stringify({
+		statusCode: error.statusCode,
+		statusMessage: error.statusMessage,
+		data: error.data,
+		stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+	}, null, 2), {
+		status: error.statusCode,
+		statusText: error.statusMessage,
+		headers: { "content-type": "application/json; charset=utf-8" }
+	});
+}
+
+//#endregion
+export { handleResponse, kHandled, kNotFound };

package/dist/core/silgi.d.mts

@@ -0,0 +1,19 @@
+import { MiddlewareSetup, ServiceSetup, ServicesObject, Silgi, SilgiEvent, SilgiRuntimeContext, StandardSchemaV1, WebSocketOptions } from "silgi/types";
+
+//#region src/core/silgi.d.ts
+
+/**
+* Fetch API for Silgi framework
+*/
+declare function silgiFetch<Service extends ServicesObject = ServicesObject, Path extends keyof Service = keyof Service>(_request: Path, options?: RequestInit, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+/**
+* Fetch API for Silgi framework using standard Request options
+*/
+declare function silgiFetch(_request: Request | URL, options?: RequestInit & {
+  path?: Record<string, any>;
+}, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+declare function middleware(event: SilgiEvent): Promise<any>;
+declare function handler(event: SilgiEvent): Promise<any>;
+declare function getWebsocket(silgi?: Silgi): WebSocketOptions;
+//#endregion
+export { getWebsocket as getWebsocket$1, handler as handler$1, middleware as middleware$1, silgiFetch as silgiFetch$1 };

package/dist/core/silgi.mjs

@@ -0,0 +1,141 @@
+import { useSilgi } from "./unctx.mjs";
+import { createError, isError } from "./error.mjs";
+import { SilgiHttpEvent } from "./event.mjs";
+import { handleResponse, kNotFound } from "./response.mjs";
+import { orchestrate } from "./orchestrate.mjs";
+import { findAllRoutes, findRoute } from "rou3";
+
+//#region src/core/silgi.ts
+function getHeader(name, headers) {
+	if (!headers) return;
+	if (headers instanceof Headers) return headers.get(name);
+	const lName = name.toLowerCase();
+	if (Array.isArray(headers)) return headers.find((h) => h[0] === name || lName === h[0].toLowerCase())?.[1];
+	return headers[name] || headers[lName];
+}
+function substitutePathParams(path, pathParams) {
+	if (!pathParams) return path;
+	return path.replace(/:(\w+)/g, (_, key) => {
+		if (key in pathParams) return encodeURIComponent(pathParams[key]);
+		return `:${key}`;
+	});
+}
+function withDuplexIfBody(options) {
+	if (!options) return options;
+	if (options.body && !("duplex" in options)) return {
+		...options,
+		duplex: "half"
+	};
+	return options;
+}
+async function silgiFetch(_request, options, context) {
+	let request;
+	if (typeof _request === "string") {
+		_request = substitutePathParams(_request, options?.pathParams);
+		let url = _request;
+		if (url[0] === "/") {
+			const host = getHeader("Host", options?.headers) || ".";
+			const proto = getHeader("X-Forwarded-Proto", options?.headers) === "https" ? "https" : "http";
+			url = `${proto}://${host}${url}`;
+		}
+		request = new Request(url, withDuplexIfBody(options));
+	} else if (options || _request instanceof URL) request = new Request(_request, withDuplexIfBody(options));
+	else request = _request;
+	const silgiEvent = new SilgiHttpEvent(request, context);
+	let handlerRes;
+	try {
+		handlerRes = handler(silgiEvent);
+	} catch (error) {
+		handlerRes = Promise.reject(error);
+	}
+	return handleResponse(handlerRes, silgiEvent, {});
+}
+async function middleware(event) {
+	const silgiContext = useSilgi();
+	event._chain = Promise.resolve(await silgiContext.callHook("request:on", event));
+	let _chain = void 0;
+	const _middleware = silgiContext.globalMiddlewares;
+	if (_middleware) {
+		_chain = _chain || Promise.resolve();
+		for (const m of _middleware) _chain = _chain.then(async (_previous) => {
+			if (_previous !== void 0 && _previous !== kNotFound) return _previous;
+			if (!(m.method === event.req.method) || !m.middleware) return;
+			try {
+				await silgiContext.callHook("middleware:global:on", event, m.middleware);
+			} catch (error) {
+				if (isError(error)) throw error;
+				throw createError({
+					message: "Middleware error",
+					statusCode: 500,
+					statusMessage: "Middleware error",
+					cause: error
+				});
+			}
+			return m.middleware.handler?.(event, silgiContext);
+		});
+	}
+	const _mRouter = silgiContext._middlewareRouter;
+	if (_mRouter) {
+		const matches = findAllRoutes(_mRouter, event.req.method, event.url.pathname);
+		if (matches.length > 0) {
+			_chain = _chain || Promise.resolve();
+			for (const match of matches) _chain = _chain.then(async (_previous) => {
+				if (_previous !== void 0 && _previous !== kNotFound) return _previous;
+				if (!(match.data.method === event.req.method) || !match.data.middleware) return;
+				event.context.params = match.params;
+				event.context.matchedRoute = match.data;
+				try {
+					await silgiContext.callHook("middleware:router:on", event, match.data.middleware);
+				} catch (error) {
+					if (isError(error)) throw error;
+					throw createError({
+						message: "Middleware error",
+						statusCode: 500,
+						statusMessage: "Middleware error",
+						cause: error
+					});
+				}
+				return match.data.middleware.handler?.(event, silgiContext);
+			});
+		}
+	}
+	event._chain = _chain;
+	if (event._chain) {
+		const data = await event._chain;
+		if (data !== void 0 && data !== kNotFound) return data;
+	}
+}
+async function handler(event) {
+	await middleware(event);
+	const silgiContext = useSilgi();
+	if (silgiContext.router) {
+		const match = findRoute(silgiContext.router, event.req.method, event.url.pathname);
+		if (match) if (event._chain) return event._chain.then(async (_previous) => {
+			if (_previous !== void 0 && _previous !== kNotFound) return _previous;
+			event.context.params = match.params;
+			event.context.matchedRoute = match.data;
+			return orchestrate(match.data, event);
+		});
+		else {
+			event.context.params = match.params;
+			event.context.matchedRoute = match.data;
+			return orchestrate(match.data, event);
+		}
+	}
+	return event._chain ? event._chain.then((_previous) => _previous === void 0 ? kNotFound : _previous) : kNotFound;
+}
+function getWebsocket(silgi = useSilgi()) {
+	return {
+		...silgi.options.websocket,
+		resolve: async (request) => {
+			const _method = request.method || "GET";
+			const event = new SilgiHttpEvent(request, {});
+			const silgiContext = useSilgi();
+			const handler$1 = silgiContext.router && findRoute(silgiContext.router, event.req.method, event.url.pathname);
+			return handler$1?.data.service?.websocket || {};
+		}
+	};
+}
+
+//#endregion
+export { getWebsocket, handler, middleware, silgiFetch };

package/dist/core/silgiApp.d.mts

@@ -0,0 +1,9 @@
+import { UseContext } from "unctx";
+import { SilgiCLI } from "silgi/types";
+
+//#region src/core/silgiApp.d.ts
+declare const silgiCLICtx: UseContext<SilgiCLI>;
+declare function useSilgiCLI(): SilgiCLI;
+declare function tryUseSilgiCLI(): SilgiCLI | null;
+//#endregion
+export { silgiCLICtx as silgiCLICtx$1, tryUseSilgiCLI as tryUseSilgiCLI$1, useSilgiCLI as useSilgiCLI$1 };

package/dist/core/silgiApp.mjs

@@ -0,0 +1,23 @@
+import consola from "consola";
+import { getContext } from "unctx";
+
+//#region src/core/silgiApp.ts
+const silgiCLICtx = getContext("silgiCLI");
+function useSilgiCLI() {
+	const instance = silgiCLICtx.tryUse();
+	if (!instance) throw new Error("Silgi instance is unavailable!");
+	return instance;
+}
+async function silgiCLIIClose() {
+	const silgi = silgiCLICtx.tryUse();
+	if (!silgi) return;
+	await silgi.close();
+	await silgi.callHook("close", silgi);
+	consola.withTag("silgi").success("Process terminated");
+}
+function tryUseSilgiCLI() {
+	return silgiCLICtx.tryUse();
+}
+
+//#endregion
+export { silgiCLICtx, silgiCLIIClose, tryUseSilgiCLI, useSilgiCLI };

package/dist/core/storage.d.mts

@@ -0,0 +1,7 @@
+import { Storage } from "unstorage";
+import { Silgi, SilgiStorageBase } from "silgi/types";
+
+//#region src/core/storage.d.ts
+declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage["mount"]>[1]) => T;
+//#endregion
+export { storageMount as storageMount$1 };

package/dist/core/storage.mjs

@@ -0,0 +1,15 @@
+import { useSilgi } from "./unctx.mjs";
+
+//#region src/core/storage.ts
+function storageMount(silgi) {
+	const _silgi = silgi || useSilgi();
+	return (base, driver) => {
+		const existingStorage = _silgi.storage.getMount(base);
+		if (existingStorage) return existingStorage.driver;
+		const storage = _silgi.storage.mount(base, driver);
+		return storage;
+	};
+}
+
+//#endregion
+export { storageMount };

package/dist/core/unctx.d.mts

@@ -0,0 +1,21 @@
+import { UseContext } from "unctx";
+import { Silgi } from "silgi/types";
+
+//#region src/core/unctx.d.ts
+declare const silgiCtx: UseContext<Silgi>;
+declare function useSilgi(): Silgi;
+/**
+* Get access to Nuxt instance.
+*
+* Returns null if Nuxt instance is unavailable.
+* @example
+* ```js
+* const silgi = tryUseSilgi()
+* if (silgi) {
+*  // Do something
+* }
+* ```
+*/
+declare function tryUseSilgi(): Silgi | null;
+//#endregion
+export { silgiCtx as silgiCtx$1, tryUseSilgi as tryUseSilgi$1, useSilgi as useSilgi$1 };

package/dist/core/unctx.mjs

@@ -0,0 +1,35 @@
+import { getContext } from "unctx";
+
+//#region src/core/unctx.ts
+const silgiCtx = getContext("silgi");
+function useSilgi() {
+	const instance = silgiCtx.tryUse();
+	if (!instance) throw new Error("Silgi instance is unavailable!");
+	return instance;
+}
+function normalizeResult(result) {
+	if (Array.isArray(result)) return [...result];
+	if (result && typeof result === "object") {
+		if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) return Object.values(result);
+		return { ...result };
+	}
+	return result;
+}
+/**
+* Get access to Nuxt instance.
+*
+* Returns null if Nuxt instance is unavailable.
+* @example
+* ```js
+* const silgi = tryUseSilgi()
+* if (silgi) {
+*  // Do something
+* }
+* ```
+*/
+function tryUseSilgi() {
+	return silgiCtx.tryUse();
+}
+
+//#endregion
+export { normalizeResult, silgiCtx, tryUseSilgi, useSilgi };

package/dist/core/utils/event-stream.d.mts

@@ -0,0 +1,53 @@
+import { EventStream$1 as EventStream } from "./internal/event-stream.mjs";
+import { SilgiEvent } from "silgi/types";
+
+//#region src/core/utils/event-stream.d.ts
+interface EventStreamOptions {
+  /**
+  * Automatically close the writable stream when the request is closed
+  *
+  * Default is `true`
+  */
+  autoclose?: boolean;
+}
+/**
+* See https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#fields
+*/
+interface EventStreamMessage {
+  id?: string;
+  event?: string;
+  retry?: number;
+  data: string;
+}
+/**
+* Initialize an EventStream instance for creating [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+*
+* @experimental This function is experimental and might be unstable in some environments.
+*
+* @example
+*
+* ```ts
+* import { createEventStream, sendEventStream } from "h3";
+*
+* app.get("/sse", (event) => {
+*   const eventStream = createEventStream(event);
+*
+*   // Send a message every second
+*   const interval = setInterval(async () => {
+*     await eventStream.push("Hello world");
+*   }, 1000);
+*
+*   // cleanup the interval and close the stream when the connection is terminated
+*   eventStream.onClosed(async () => {
+*     console.log("closing SSE...");
+*     clearInterval(interval);
+*     await eventStream.close();
+*   });
+*
+*   return eventStream.send();
+* });
+* ```
+*/
+declare function createEventStream(event: SilgiEvent, opts?: EventStreamOptions): EventStream;
+//#endregion
+export { EventStreamMessage, EventStreamOptions, createEventStream as createEventStream$1 };

package/dist/core/utils/event-stream.mjs

@@ -0,0 +1,38 @@
+import { EventStream } from "./internal/event-stream.mjs";
+
+//#region src/core/utils/event-stream.ts
+/**
+* Initialize an EventStream instance for creating [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+*
+* @experimental This function is experimental and might be unstable in some environments.
+*
+* @example
+*
+* ```ts
+* import { createEventStream, sendEventStream } from "h3";
+*
+* app.get("/sse", (event) => {
+*   const eventStream = createEventStream(event);
+*
+*   // Send a message every second
+*   const interval = setInterval(async () => {
+*     await eventStream.push("Hello world");
+*   }, 1000);
+*
+*   // cleanup the interval and close the stream when the connection is terminated
+*   eventStream.onClosed(async () => {
+*     console.log("closing SSE...");
+*     clearInterval(interval);
+*     await eventStream.close();
+*   });
+*
+*   return eventStream.send();
+* });
+* ```
+*/
+function createEventStream(event, opts) {
+	return new EventStream(event, opts);
+}
+
+//#endregion
+export { createEventStream };

package/dist/core/utils/event.d.mts

@@ -0,0 +1,8 @@
+import { SilgiEvent, SilgiRuntimeContext } from "silgi/types";
+
+//#region src/core/utils/event.d.ts
+// import { isRuntimePresents } from 'silgi/kit'
+declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
+declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): T;
+//#endregion
+export { getEvent as getEvent$1, getEventContext as getEventContext$1 };

package/dist/core/utils/event.mjs

@@ -0,0 +1,12 @@
+//#region src/core/utils/event.ts
+function getEvent(event) {
+	if (event?.event) return getEvent(event.event);
+	return event;
+}
+function getEventContext(event) {
+	const _event = getEvent(event);
+	return _event.context;
+}
+
+//#endregion
+export { getEvent, getEventContext };

package/dist/core/utils/internal/event-stream.d.mts

@@ -0,0 +1,45 @@
+import { EventStreamMessage, EventStreamOptions } from "../event-stream.mjs";
+import { SilgiEvent } from "silgi/types";
+
+//#region src/core/utils/internal/event-stream.d.ts
+
+/**
+* A helper class for [server sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format)
+*/
+declare class EventStream {
+  private readonly _event;
+  private readonly _transformStream;
+  private readonly _writer;
+  private readonly _encoder;
+  private _writerIsClosed;
+  private _paused;
+  private _unsentData;
+  private _disposed;
+  private _handled;
+  constructor(event: SilgiEvent, opts?: EventStreamOptions);
+  /**
+  * Publish new event(s) for the client
+  */
+  push(message: string): Promise<void>;
+  push(message: string[]): Promise<void>;
+  push(message: EventStreamMessage): Promise<void>;
+  push(message: EventStreamMessage[]): Promise<void>;
+  private _sendEvent;
+  private _sendEvents;
+  pause(): void;
+  get isPaused(): boolean;
+  resume(): Promise<void>;
+  flush(): Promise<void>;
+  /**
+  * Close the stream and the connection if the stream is being sent to the client
+  */
+  close(): Promise<void>;
+  /**
+  * Triggers callback when the writable stream is closed.
+  * It is also triggered after calling the `close()` method.
+  */
+  onClosed(cb: () => any): void;
+  send(): Promise<BodyInit>;
+}
+//#endregion
+export { EventStream as EventStream$1 };