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