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