1 | import { IncomingMessage, ServerResponse, OutgoingMessage } from 'node:http';
|
2 | export { IncomingMessage as NodeIncomingMessage, ServerResponse as NodeServerResponse } from 'node:http';
|
3 | import { CookieSerializeOptions } from 'cookie-es';
|
4 | import * as ufo from 'ufo';
|
5 |
|
6 | declare type HTTPMethod = "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE";
|
7 | declare type Encoding = false | "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex";
|
8 | interface H3EventContext extends Record<string, any> {
|
9 | }
|
10 | declare type EventHandlerResponse<T = any> = T | Promise<T>;
|
11 | interface EventHandler<T = any> {
|
12 | "__is_handler__"?: true;
|
13 | (event: H3Event): EventHandlerResponse<T>;
|
14 | }
|
15 | declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
|
16 | declare type RequestHeaders = {
|
17 | [name: string]: string | undefined;
|
18 | };
|
19 |
|
20 | declare type NodeListener = (req: IncomingMessage, res: ServerResponse) => void;
|
21 | declare type NodePromisifiedHandler = (req: IncomingMessage, res: ServerResponse) => Promise<any>;
|
22 | declare type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
|
23 | declare const defineNodeListener: (handler: NodeListener) => NodeListener;
|
24 | declare const defineNodeMiddleware: (middleware: NodeMiddleware) => NodeMiddleware;
|
25 | declare function fromNodeMiddleware(handler: NodeListener | NodeMiddleware): EventHandler;
|
26 | declare function toNodeListener(app: App): NodeListener;
|
27 | declare function promisifyNodeListener(handler: NodeListener | NodeMiddleware): NodePromisifiedHandler;
|
28 | declare function callNodeListener(handler: NodeMiddleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
|
29 |
|
30 | declare class H3Headers implements Headers {
|
31 | _headers: Record<string, string>;
|
32 | constructor(init?: HeadersInit);
|
33 | [Symbol.iterator](): IterableIterator<[string, string]>;
|
34 | entries(): IterableIterator<[string, string]>;
|
35 | keys(): IterableIterator<string>;
|
36 | values(): IterableIterator<string>;
|
37 | append(name: string, value: string): void;
|
38 | delete(name: string): void;
|
39 | get(name: string): string | null;
|
40 | has(name: string): boolean;
|
41 | set(name: string, value: string): void;
|
42 | forEach(callbackfn: (value: string, key: string, parent: Headers) => void): void;
|
43 | }
|
44 |
|
45 | declare class H3Response implements Response {
|
46 | readonly headers: H3Headers;
|
47 | readonly status: number;
|
48 | readonly statusText: string;
|
49 | readonly redirected: boolean;
|
50 | readonly ok: boolean;
|
51 | readonly url: string;
|
52 | _body: string | ArrayBuffer | Uint8Array;
|
53 | readonly body: ReadableStream<Uint8Array> | null;
|
54 | readonly type: ResponseType;
|
55 | readonly bodyUsed = false;
|
56 | constructor(body?: BodyInit | EventHandlerResponse | null, init?: ResponseInit);
|
57 | clone(): H3Response;
|
58 | arrayBuffer(): Promise<ArrayBuffer>;
|
59 | blob(): Promise<Blob>;
|
60 | formData(): Promise<FormData>;
|
61 | json<T = any>(): Promise<T>;
|
62 | text(): Promise<string>;
|
63 | }
|
64 |
|
65 | interface NodeEventContext {
|
66 | req: IncomingMessage;
|
67 | res: ServerResponse;
|
68 | }
|
69 | declare class H3Event implements Pick<FetchEvent, "respondWith"> {
|
70 | "__is_event__": boolean;
|
71 | node: NodeEventContext;
|
72 | context: H3EventContext;
|
73 | constructor(req: IncomingMessage, res: ServerResponse);
|
74 | get path(): string | undefined;
|
75 | /** @deprecated Please use `event.node.res` instead. **/
|
76 | get req(): IncomingMessage;
|
77 | /** @deprecated Please use `event.node.res` instead. **/
|
78 | get res(): ServerResponse<IncomingMessage>;
|
79 | respondWith(r: H3Response | PromiseLike<H3Response>): void;
|
80 | }
|
81 | declare function isEvent(input: any): input is H3Event;
|
82 | declare function createEvent(req: IncomingMessage, res: ServerResponse): H3Event;
|
83 |
|
84 | declare function defineEventHandler<T = any>(handler: EventHandler<T>): EventHandler<T>;
|
85 | declare const eventHandler: typeof defineEventHandler;
|
86 | declare function isEventHandler(input: any): input is EventHandler;
|
87 | declare function toEventHandler(input: any, _?: any, _route?: string): EventHandler;
|
88 | interface DynamicEventHandler extends EventHandler {
|
89 | set: (handler: EventHandler) => void;
|
90 | }
|
91 | declare function dynamicEventHandler(initial?: EventHandler): DynamicEventHandler;
|
92 | declare function defineLazyEventHandler(factory: LazyEventHandler): EventHandler;
|
93 | declare const lazyEventHandler: typeof defineLazyEventHandler;
|
94 |
|
95 | interface Layer {
|
96 | route: string;
|
97 | match?: Matcher;
|
98 | handler: EventHandler;
|
99 | }
|
100 | declare type Stack = Layer[];
|
101 | interface InputLayer {
|
102 | route?: string;
|
103 | match?: Matcher;
|
104 | handler: EventHandler;
|
105 | lazy?: boolean;
|
106 | }
|
107 | declare type InputStack = InputLayer[];
|
108 | declare type Matcher = (url: string, event?: H3Event) => boolean;
|
109 | interface AppUse {
|
110 | (route: string | string[], handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
|
111 | (handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
|
112 | (options: InputLayer): App;
|
113 | }
|
114 | interface AppOptions {
|
115 | debug?: boolean;
|
116 | onError?: (error: Error, event: H3Event) => any;
|
117 | }
|
118 | interface App {
|
119 | stack: Stack;
|
120 | handler: EventHandler;
|
121 | options: AppOptions;
|
122 | use: AppUse;
|
123 | }
|
124 | declare function createApp(options?: AppOptions): App;
|
125 | declare function use(app: App, arg1: string | EventHandler | InputLayer | InputLayer[], arg2?: Partial<InputLayer> | EventHandler | EventHandler[], arg3?: Partial<InputLayer>): App;
|
126 | declare function createAppEventHandler(stack: Stack, options: AppOptions): EventHandler<void>;
|
127 |
|
128 |
|
129 |
|
130 |
|
131 |
|
132 |
|
133 |
|
134 |
|
135 |
|
136 |
|
137 |
|
138 |
|
139 |
|
140 | declare class H3Error extends Error {
|
141 | static __h3_error__: boolean;
|
142 | toJSON(): Pick<H3Error, "statusCode" | "statusMessage" | "data" | "message">;
|
143 | statusCode: number;
|
144 | fatal: boolean;
|
145 | unhandled: boolean;
|
146 | statusMessage?: string;
|
147 | data?: any;
|
148 | }
|
149 |
|
150 |
|
151 |
|
152 |
|
153 |
|
154 |
|
155 | declare function createError(input: string | Partial<H3Error> & {
|
156 | status?: number;
|
157 | statusText?: string;
|
158 | }): H3Error;
|
159 |
|
160 |
|
161 |
|
162 |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 |
|
168 |
|
169 | declare function sendError(event: H3Event, error: Error | H3Error, debug?: boolean): void;
|
170 | declare function isError(input: any): input is H3Error;
|
171 |
|
172 | declare function useBase(base: string, handler: EventHandler): EventHandler;
|
173 |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 | declare function readRawBody(event: H3Event, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer | undefined>;
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 | declare function readBody<T = any>(event: H3Event): Promise<T>;
|
194 |
|
195 | interface CacheConditions {
|
196 | modifiedTime?: string | Date;
|
197 | maxAge?: number;
|
198 | etag?: string;
|
199 | cacheControls?: string[];
|
200 | }
|
201 |
|
202 |
|
203 |
|
204 |
|
205 |
|
206 | declare function handleCacheHeaders(event: H3Event, opts: CacheConditions): boolean;
|
207 |
|
208 | declare const MIMES: {
|
209 | html: string;
|
210 | json: string;
|
211 | };
|
212 |
|
213 |
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 | declare function parseCookies(event: H3Event): Record<string, string>;
|
222 |
|
223 |
|
224 |
|
225 |
|
226 |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 | declare function getCookie(event: H3Event, name: string): string | undefined;
|
232 |
|
233 |
|
234 |
|
235 |
|
236 |
|
237 |
|
238 |
|
239 |
|
240 |
|
241 |
|
242 | declare function setCookie(event: H3Event, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
|
243 |
|
244 |
|
245 |
|
246 |
|
247 |
|
248 |
|
249 |
|
250 |
|
251 |
|
252 | declare function deleteCookie(event: H3Event, name: string, serializeOptions?: CookieSerializeOptions): void;
|
253 |
|
254 | interface ProxyOptions {
|
255 | headers?: RequestHeaders | HeadersInit;
|
256 | fetchOptions?: RequestInit;
|
257 | fetch?: typeof fetch;
|
258 | sendStream?: boolean;
|
259 | }
|
260 | declare function proxyRequest(event: H3Event, target: string, opts?: ProxyOptions): Promise<void>;
|
261 | declare function sendProxy(event: H3Event, target: string, opts?: ProxyOptions): Promise<void>;
|
262 |
|
263 | declare function getQuery(event: H3Event): ufo.QueryObject;
|
264 | declare function getRouterParams(event: H3Event): H3Event["context"];
|
265 | declare function getRouterParam(event: H3Event, name: string): H3Event["context"][string];
|
266 | declare function getMethod(event: H3Event, defaultMethod?: HTTPMethod): HTTPMethod;
|
267 | declare function isMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
|
268 | declare function assertMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
|
269 | declare function getRequestHeaders(event: H3Event): RequestHeaders;
|
270 | declare const getHeaders: typeof getRequestHeaders;
|
271 | declare function getRequestHeader(event: H3Event, name: string): RequestHeaders[string];
|
272 | declare const getHeader: typeof getRequestHeader;
|
273 |
|
274 | declare function send(event: H3Event, data?: any, type?: string): Promise<void>;
|
275 | declare function defaultContentType(event: H3Event, type?: string): void;
|
276 | declare function sendRedirect(event: H3Event, location: string, code?: number): Promise<void>;
|
277 | declare function getResponseHeaders(event: H3Event): ReturnType<H3Event["res"]["getHeaders"]>;
|
278 | declare function getResponseHeader(event: H3Event, name: string): ReturnType<H3Event["res"]["getHeader"]>;
|
279 | declare function setResponseHeaders(event: H3Event, headers: Record<string, Parameters<OutgoingMessage["setHeader"]>[1]>): void;
|
280 | declare const setHeaders: typeof setResponseHeaders;
|
281 | declare function setResponseHeader(event: H3Event, name: string, value: Parameters<OutgoingMessage["setHeader"]>[1]): void;
|
282 | declare const setHeader: typeof setResponseHeader;
|
283 | declare function appendResponseHeaders(event: H3Event, headers: Record<string, string>): void;
|
284 | declare const appendHeaders: typeof appendResponseHeaders;
|
285 | declare function appendResponseHeader(event: H3Event, name: string, value: string): void;
|
286 | declare const appendHeader: typeof appendResponseHeader;
|
287 | declare function isStream(data: any): any;
|
288 | declare function sendStream(event: H3Event, data: any): Promise<void>;
|
289 | declare function writeEarlyHints(event: H3Event, hints: string | string[] | Record<string, string | string[]>, cb?: () => void): void;
|
290 |
|
291 | declare type RouterMethod = Lowercase<HTTPMethod>;
|
292 | declare type RouterUse = (path: string, handler: EventHandler, method?: RouterMethod | RouterMethod[]) => Router;
|
293 | declare type AddRouteShortcuts = Record<RouterMethod, RouterUse>;
|
294 | interface Router extends AddRouteShortcuts {
|
295 | add: RouterUse;
|
296 | use: RouterUse;
|
297 | handler: EventHandler;
|
298 | }
|
299 | interface CreateRouterOptions {
|
300 | preemtive?: boolean;
|
301 | }
|
302 | declare function createRouter(opts?: CreateRouterOptions): Router;
|
303 |
|
304 | export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CreateRouterOptions, DynamicEventHandler, Encoding, EventHandler, EventHandlerResponse, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, InputLayer, InputStack, Layer, LazyEventHandler, MIMES, Matcher, NodeEventContext, NodeListener, NodeMiddleware, NodePromisifiedHandler, ProxyOptions, RequestHeaders, Router, RouterMethod, RouterUse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, deleteCookie, dynamicEventHandler, eventHandler, fromNodeMiddleware, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, parseCookies, promisifyNodeListener, proxyRequest, readBody, readRawBody, send, sendError, sendProxy, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, toNodeListener, use, useBase, writeEarlyHints };
|