k99 0.2.0 → 0.3.0-beta.1

package/types.d.ts

@@ -0,0 +1,748 @@
+/*!
+ * k99 v0.3.0-beta.1
+ * (c) 2019-2022 Fierflame
+ * @license MIT
+ */
+/**
+ * 服务
+ */
+declare abstract class Service<T = unknown, P extends any[] = []> implements Context {
+    /**
+     * @warning 不要重载构造函数或者主动调用创建实例
+     */
+    constructor(context: Context);
+    readonly context: Context;
+    abstract export(...p: P): T;
+    /** 销毁时，会自动调用此方法销毁自动创建的容器 */
+    destroy(): Promise<void>;
+}
+interface Service extends Context {
+}
+declare namespace Service {
+    interface Constructor<T, P extends any[] = []> {
+        new (context: Context): Service<T, P>;
+        prototype: Service<T, P>;
+    }
+    interface Func<T, P extends any[] = []> {
+        (context: Context, ...p: P): T;
+    }
+}
+
+/**
+ * 路由卫士
+ * @description 用于路由的过滤及处理函数执行前的预处理
+ */
+declare abstract class Guard<T = unknown> extends Service<T> {
+    decide(): void | boolean | null | undefined | Promise<void | boolean | null | undefined>;
+    /**
+     * 测试请求是否允许通过此路由访问
+     * @description 同一请求、同一路径下，在此函数中调用的 this.set、this.get、this.delete、this.has、this.keys、this.clear 等方法的数据与实例初始化后的共享。目前不同路径下暂不共享，后续可能会被设计为共享，但不同请求下必然不共享
+     * @description 同一路径下，若存在任意 test 返回 false 均会使得此路径不会被执行
+     * @param param 请求参数
+     */
+    static test(param?: {
+        [k: string]: string | string[] | undefined;
+    }): Promise<boolean>;
+    /**
+     * @description 映射的 Map 实例的 set 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    set(k: any, v: any): this;
+    /**
+     * @description 映射的 Map 实例的 get 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    get(k: any): any;
+    /**
+     * @description 映射的 Map 实例的 delete 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    delete(k: any): boolean;
+    /**
+     * @description 映射的 Map 实例的 has 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    has(k: any): boolean;
+    /**
+     * @description 映射的 Map 实例的 keys 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    keys(): IterableIterator<any>;
+    /**
+     * @description 映射的 Map 实例的 clear 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    clear(): void;
+    /**
+     * @description 映射的 Map 实例的 size 属性，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    get size(): number;
+    /**
+     * @description 映射的 Map 实例的 set 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static set(k: any, v: any): typeof Guard;
+    /**
+     * @description 映射的 Map 实例的 get 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static get(k: any): any;
+    /**
+     * @description 映射的 Map 实例的 delete 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static delete(k: any): boolean;
+    /**
+     * @description 映射的 Map 实例的 has 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static has(k: any): boolean;
+    /**
+     * @description 映射的 Map 实例的 keys 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static keys(): IterableIterator<any>;
+    /**
+     * @description 映射的 Map 实例的 clear 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static clear(): void;
+    /**
+     * @description 映射的 Map 实例的 size 属性，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+     */
+    static get size(): number;
+}
+declare namespace Guard {
+    interface Constructor<T> extends Service.Constructor<T> {
+        new (context: Context): Guard<T>;
+        prototype: Guard<T>;
+        test(param: {
+            [k: string]: string | string[] | undefined;
+        }): void | boolean | null | undefined | Promise<void | boolean | null | undefined>;
+    }
+}
+
+declare const returnSymbol: unique symbol;
+declare const catchSymbol: unique symbol;
+declare const finallySymbol: unique symbol;
+declare const dataSymbol: unique symbol;
+declare const initSymbol: unique symbol;
+declare const methodsSymbol: unique symbol;
+declare const testSymbol: unique symbol;
+declare const optionsSymbol: unique symbol;
+
+/**
+ * 处理器
+ */
+declare class Controller implements Context {
+    static isControllerConstructor(v: any): v is Controller.Constructor<any>;
+    readonly context: Context;
+    /**
+     * @warning 不要重载构造函数或者主动调用创建实例
+     */
+    constructor(context: Context);
+    /**
+     * 初始化
+     * @description 如果有初始化操作，应当在 init 中实现
+     * @description 此方法由路由调用
+     */
+    [initSymbol](): void | Promise<void>;
+    /** 处理函数的第一个参数 */
+    [dataSymbol](): Record<string, any> | Promise<Record<string, any>>;
+    /**
+     * OPTIONS 的默认处理函数
+     * @description 如果需要，则需要在此函数中实现
+     * @description 当已 OPTIONS 方法请求资源，且资源对应的路径中没有定义 OPTIONS 方法处理是的处理函数
+     */
+    [optionsSymbol](): void | undefined | WriteType | Promise<void | undefined | WriteType>;
+    /**
+     * 对处理函数的结果进行处理
+     * @description 如果需要自定义处理，需要重载此方法
+     * @description 此方法由路由调用
+     * @param result 处理函数的结果
+     */
+    [returnSymbol](result: any): void | PromiseLike<void>;
+    /**
+     * 处理完成后，实例销毁前，如果有错误未被处理，将回交由此参数处理
+     * @description 如果需要自定义处理，需要重载此方法
+     * @description 此方法由路由调用
+     */
+    [catchSymbol](e: any): void | PromiseLike<void>;
+    /**
+     * 处理完成后，实例即将销毁时的处理函数
+     * @description 如果有销毁操作，应当在 finally 中通过实现
+     * @description 此方法由 destroy 调用
+     */
+    [finallySymbol](): void | PromiseLike<void>;
+}
+interface Controller extends Context {
+}
+declare namespace Controller {
+    interface Constructor<T extends Controller> {
+        new (context: Context): T;
+        prototype: T;
+    }
+}
+
+declare class Router {
+    disabled: boolean;
+    /** 当前路由路径 */
+    readonly path: string;
+    /** 路由列表 */
+    private readonly __routes;
+    readonly match: Match;
+    constructor(path?: string);
+    /** 子路由 */
+    route(path: string | Router): Router;
+    controller?: Controller.Constructor<any>;
+    readonly guards: Set<Guard.Constructor<any>>;
+    /**
+     * 注册处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    verb(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param methods 有效的 HTTP 请求方法
+     * @param options 选项
+     */
+    verb(path: string, handle: Handle<any>, methods: Method | Method[], options?: Handle.Options): this;
+    verb(path: string, handle: Handle<any>, methods?: Method | Method[] | Handle.Options, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP GET 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    get(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP POST 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    post(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP PUT 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    put(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP DELETE 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    delete(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP HEAD 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    head(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP OPTIONS 处理函数
+     * @param path    要注册的路径
+     * @param handle  要注册的处理函数
+     * @param options 选项
+     */
+    options(path: string, handle: Handle<any>, options?: Handle.Options): this;
+    /**
+     * 注册 HTTP 资源
+     * @param exports 要注册的资源
+     * @param options 选项
+     */
+    resource(exports: Exports, options?: ResourceOption): this;
+    register(exports: Exports | Controller.Constructor<any>, options?: ResourceOption): this;
+    /**
+     * 注册 HTTP 处理函数集
+     * @param exports 要注册的处理函数集
+     * @param options 选项
+     */
+    collection(exports: Exports, options?: ResourceOption): this;
+    /**
+     * 注册 HTTP 资源成员处理函数集
+     * @param exports 要注册的处理函数集
+     * @param options 选项
+     */
+    member(exports: Exports, options?: ResourceOption): this;
+}
+
+declare abstract class Plugin {
+    /** 包名 */
+    readonly name: string;
+    /** 版本 */
+    readonly version: string;
+    /** 作者 */
+    readonly author: string;
+    /** 开源协议 */
+    readonly license: string;
+    constructor(name: string, 
+    /** 版本 */
+    version: string, { author, license }?: {
+        /** 作者 */
+        author?: string;
+        /** 开源协议 */
+        license?: string;
+    });
+    abstract readSettings(path: string): any | Promise<any>;
+    abstract readAsset(path: string, encoding?: false): Promise<ArrayBuffer | null>;
+    abstract readAsset(path: string, options: true): Promise<string | null>;
+    abstract readAsset(path: string, options?: boolean): Promise<string | ArrayBuffer | null>;
+    private __initRouterPromise;
+    protected _initRouter(router: Router): Promise<void> | void;
+    initRouter(): Promise<Router>;
+    get router(): Router;
+    get disabled(): boolean;
+    set disabled(t: boolean);
+}
+
+declare class App extends Router {
+    /** 连接的处理函数 */
+    readonly request: (request: K99Request) => Promise<null | K99Response>;
+    /** 设置接口 */
+    readonly settings: Settings;
+    /** 资产接口 */
+    readonly assets: Assets;
+    /** 日志接口 */
+    readonly logs: Log;
+    readonly plugins: Record<string, Plugin>;
+    constructor({ router, settingApi, assetApi, logApi, path, }?: App.Options, plugins?: Record<string, Plugin>);
+}
+declare namespace App {
+    interface Options {
+        path?: string;
+        router?: Router;
+        assetApi?: Assets.Api;
+        settingApi?: Settings.Api;
+        logApi?: Log.Api;
+    }
+}
+
+declare type MaybePromise<T> = T | Promise<T>;
+declare type PromiseValue<T> = T extends PromiseLike<infer V> ? V : T;
+
+declare type BaseWriteType = string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView;
+declare type WriteType = BaseWriteType | AsyncIterable<WriteType> | Iterable<WriteType>;
+
+/** 处理函数定义 */
+interface Handle<T extends Record<string, any>> extends Handle.Attrs<T> {
+    (this: Context, data: T): MaybePromise<void | undefined | WriteType | object>;
+}
+declare function Handle<T extends Record<string, any>>(handle: Handle<T> | Handles<T>): Handle<T> | Handles<T>;
+declare namespace Handle {
+    /** 处理函数选项选项 */
+    interface Attrs<T extends Record<string, any>> {
+        /** 方法列表 */
+        [methodsSymbol]?: Method | Method[];
+        [testSymbol]?(param: {
+            [k: string]: string | string[] | undefined;
+        }): boolean | Promise<boolean>;
+        [optionsSymbol]?: Handle<T> | Option;
+    }
+    interface Option {
+        [key: string]: any;
+    }
+    interface Options extends ResourceOption {
+        /** 处理函数的名称 */
+        name?: string;
+        /** 方法列表 */
+        methods?: Method | Method[];
+        /** 文件导出的内容 */
+        exports?: Exports;
+        /** 测试函数 */
+        test?(param: {
+            [k: string]: string | string[] | undefined;
+        }): boolean | Promise<boolean>;
+    }
+}
+/** 处理函数定义 */
+interface Handles<T extends Record<string, any>> extends Handle.Attrs<T> {
+    OPTIONS?: Handle<T>;
+    GET?: Handle<T>;
+    POST?: Handle<T>;
+    PUT?: Handle<T>;
+    DELETE?: Handle<T>;
+    HEAD?: Handle<T>;
+}
+interface ResourceOption {
+    /** 控制器 */
+    controller?: Controller.Constructor<any>;
+    /** 所属组 */
+    plugin?: string;
+    /** 包根目录 */
+    root?: string;
+    /** 当前文件相对于包根目录的路径 */
+    filePath?: string;
+    /** 当前文件的绝对路径 */
+    absPath?: string;
+}
+
+declare type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface Match {
+    (pathname: string, parent: string, key: number): null | Match.Result;
+    keyLen: number;
+    isRoot?: boolean;
+}
+declare namespace Match {
+    interface Result {
+        $path: string;
+        [key: string]: any;
+    }
+}
+interface Route {
+    /** 请求路径 */
+    path: string;
+    /** 路径匹配 */
+    match: Match;
+    /** 所属插件 */
+    plugin?: string;
+    /** 处理函数 */
+    handle: Handle<any> | typeof optionsSymbol | string;
+    /** 方法列表 */
+    methods: Method[];
+    /** 控制器 */
+    controller?: Controller.Constructor<any>;
+    /** 包根目录 */
+    root?: string;
+    /** 当前文件相对于包根目录的路径 */
+    filePath?: string;
+    /** 当前文件的绝对路径 */
+    absPath?: string;
+    /** 处理函数的名称 */
+    name?: string;
+    /** 测试函数 */
+    test?(param: {
+        [k: string]: string | string[] | undefined;
+    }): boolean | Promise<boolean>;
+}
+/** 处理项目文件导出 */
+interface Exports<C extends Controller = any> extends Handles<C> {
+    Controller?: Controller.Constructor<C>;
+    Guard?: Guard.Constructor<Guard<C>>;
+    index?: Handle<C> | Handles<C>;
+    new?: Handle<C> | Handles<C>;
+    create?: Handle<C> | Handles<C>;
+    show?: Handle<C> | Handles<C>;
+    update?: Handle<C> | Handles<C>;
+    destroy?: Handle<C> | Handles<C>;
+    [key: string]: any;
+}
+
+interface CookieClearOption {
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+}
+interface CookieOption extends CookieClearOption {
+    expire?: string;
+}
+interface CookieOptionInfo extends CookieOption {
+    value: string;
+}
+
+interface K99Response extends AsyncIterable<BaseWriteType> {
+    statusCode: number;
+    finished: boolean;
+    headers: K99Response.Headers;
+}
+declare namespace K99Response {
+    interface Headers {
+        [header: string]: number | string | string[];
+    }
+}
+
+interface Settings {
+    (): string;
+    (path: string): this;
+    (path: string, mark: true): this;
+    /** 读取配置 */
+    read(path: string): Promise<object | null | undefined>;
+    /** 写入配置 */
+    write(path: string, cfg?: object | null | undefined): Promise<boolean>;
+}
+declare namespace Settings {
+    interface Api {
+        /** 读取配置 */
+        read?(path: string): Promise<object | null | undefined>;
+        /** 写入配置 */
+        write?(path: string, cfg: object | null | undefined): Promise<boolean>;
+    }
+}
+
+interface Assets {
+    (): string;
+    (path: string): this;
+    (path: string, mark: true): this;
+    /** 读取文件 */
+    read(path: string, encoding?: false): Promise<ArrayBuffer | null>;
+    read(path: string, encoding: true): Promise<string | null>;
+    read(path: string, encoding?: boolean): Promise<string | ArrayBuffer | null>;
+    /** 删除文件 */
+    delete(path: string): Promise<boolean>;
+    /** 写入文件 */
+    write(path: string, data: any): Promise<boolean>;
+    /** 获取文件信息 */
+    stat(path: string): Promise<Assets.Stats | null>;
+}
+declare namespace Assets {
+    interface Reader {
+        (path: string, encoding?: false): Promise<ArrayBuffer | null>;
+        (path: string, encoding: true): Promise<string | null>;
+        (path: string, encoding?: boolean): Promise<string | ArrayBuffer | null>;
+    }
+    interface Stats {
+        isDirectory: boolean;
+        size: number;
+        updateTime: Date;
+        createTime: Date;
+    }
+    interface Api {
+        /** 读取文件 */
+        read?: Reader;
+        /** 删除文件 */
+        delete?(path: string): Promise<boolean>;
+        /** 写入文件 */
+        write?(path: string, data: any): Promise<boolean>;
+        /** 获取文件信息 */
+        stat?(path: string): Promise<Stats | null>;
+    }
+}
+
+interface Log {
+    (): string;
+    (path: string): this;
+    (path: string, mark: true): this;
+    /** 读取日志 */
+    read(path: string): Promise<string>;
+    /** 写入日志 */
+    write(path: string, log: string, opt?: Log.Options): Promise<boolean>;
+    /** 清除日志 */
+    clear(path: string): Promise<void>;
+    /** 输出信息日志 */
+    debug(log: string, opt?: Log.Options): Promise<boolean>;
+    /** 输出信息日志 */
+    info(log: string, opt?: Log.Options): Promise<boolean>;
+    /** 输出警告日志 */
+    warn(log: any, opt?: Log.Options): Promise<boolean>;
+    /** 输出错误日志 */
+    error(log: any, opt?: Log.Options): Promise<boolean>;
+}
+declare namespace Log {
+    interface Options {
+        /** 在日志前添加的标签 */
+        tags?: string | string[];
+        /** 多行日志的缩进字符串，或者是缩进空格的数量 */
+        indent?: string | number;
+    }
+    interface Api {
+        /** 读取日志 */
+        read?(path: string): Promise<string>;
+        /** 写入日志 */
+        write?(path: string, log: string): Promise<boolean>;
+        /** 清除日志 */
+        clear?(path: string): Promise<void>;
+    }
+}
+
+interface K99Request {
+    readonly method: Method;
+    readonly url: string;
+    /** 请求路径 */
+    readonly pathname: string;
+    /** 查询字符串 */
+    readonly search: string;
+    /** 查询参数 */
+    readonly query: Record<string, string | string[]>;
+    readonly headers: K99Request.Headers;
+    readonly read: K99Request.Reader;
+}
+declare namespace K99Request {
+    interface Headers {
+        'accept'?: string;
+        'accept-language'?: string;
+        'accept-patch'?: string;
+        'accept-ranges'?: string;
+        'access-control-allow-credentials'?: string;
+        'access-control-allow-headers'?: string;
+        'access-control-allow-methods'?: string;
+        'access-control-allow-origin'?: string;
+        'access-control-expose-headers'?: string;
+        'access-control-max-age'?: string;
+        'age'?: string;
+        'allow'?: string;
+        'alt-svc'?: string;
+        'authorization'?: string;
+        'cache-control'?: string;
+        'connection'?: string;
+        'content-disposition'?: string;
+        'content-encoding'?: string;
+        'content-language'?: string;
+        'content-length'?: string;
+        'content-location'?: string;
+        'content-range'?: string;
+        'content-type'?: string;
+        'cookie'?: string;
+        'date'?: string;
+        'expect'?: string;
+        'expires'?: string;
+        'forwarded'?: string;
+        'from'?: string;
+        'host'?: string;
+        'if-match'?: string;
+        'if-modified-since'?: string;
+        'if-none-match'?: string;
+        'if-unmodified-since'?: string;
+        'last-modified'?: string;
+        'location'?: string;
+        'pragma'?: string;
+        'proxy-authenticate'?: string;
+        'proxy-authorization'?: string;
+        'public-key-pins'?: string;
+        'range'?: string;
+        'referer'?: string;
+        'retry-after'?: string;
+        'set-cookie'?: string[];
+        'strict-transport-security'?: string;
+        'tk'?: string;
+        'trailer'?: string;
+        'transfer-encoding'?: string;
+        'upgrade'?: string;
+        'user-agent'?: string;
+        'vary'?: string;
+        'via'?: string;
+        'warning'?: string;
+        'www-authenticate'?: string;
+        [header: string]: string | string[] | undefined;
+    }
+    interface Reader {
+        (size?: number, encoding?: false): Promise<ArrayBuffer | null>;
+        (size: number, encoding: true): Promise<string | null>;
+        (size?: number, encoding?: boolean): Promise<string | ArrayBuffer | null>;
+    }
+}
+
+interface Context {
+    /** 当前的路由 */
+    readonly app: App;
+    /** 路径参数 */
+    readonly params: Readonly<{
+        [p: string]: string;
+    }>;
+    /** 请求 accept */
+    readonly accept: string[];
+    /** 请求 accept language */
+    readonly acceptLanguage: string[];
+    /** 请求头 */
+    readonly headers: Readonly<K99Request.Headers>;
+    /** 请求方法 */
+    readonly method: Method;
+    /** 请求 url (不含协议及主机名等) */
+    readonly url: string;
+    /** 请求路径 */
+    readonly pathname: string;
+    /** 查询字符串 */
+    readonly search: string;
+    /** 查询参数 */
+    readonly query: Record<string, string | string[]>;
+    /** 来源路径 */
+    readonly referer: string;
+    /** 请求主机 */
+    readonly host: string;
+    /** 请求主机名 */
+    readonly hostname: string;
+    /** 请求端口 */
+    readonly port: string;
+    /** 客户端 UA */
+    readonly userAgent: string;
+    /** 处理程序所属插件 */
+    readonly plugin?: string;
+    readonly settings: Settings;
+    readonly assets: Assets;
+    readonly logs: Log;
+    /** 请求 cookie */
+    readonly cookies: Readonly<{
+        [key: string]: string;
+    }>;
+    readonly destroyed: boolean;
+    readonly finished: boolean;
+    /** 响应头是否已经被发送 */
+    readonly headersSent: boolean;
+    readonly requestType: string;
+    responseType: string | number | string[];
+    /** 状态码 */
+    status: number;
+    readonly data: any;
+    body: any;
+    /**
+     * 获取已设置的 cookie 信息
+     */
+    getCookie(name?: string): Iterable<CookieOptionInfo>;
+    /**
+     * 设置 cookie
+     * @param name cookie 名称
+     * @param value cookie 内容
+     * @param option 选项
+     */
+    setCookie(name: string, value: string, opt?: CookieOption): void;
+    readonly clearCookie: {
+        /**
+         * 清除 cookie
+         * @param name  cookie 名称
+         * @param option 选项
+         */
+        (name: string, option?: CookieClearOption): void;
+        /**
+         * 清除所有的 cookie
+         * @param option 选项
+         * @param all 是否包括请求 cookie 在内的 cookie 都要清除
+         */
+        (option?: CookieClearOption, all?: boolean): void;
+    };
+    service<T, P extends any[] = []>(Service: Service.Constructor<T, P> | Service.Func<T, P>, ...p: P): T;
+    hasHeader(name: string): boolean;
+    getHeader(name: string): string | number | string[] | undefined;
+    setHeader(name: string, value?: string | number | string[]): void;
+    removeHeader(name: string): void;
+    getHeaderNames(): string[];
+    getHeaders(): K99Response.Headers;
+    readonly read: K99Request.Reader;
+    /** 将数据写入相应 */
+    write(chunk: WriteType): Promise<boolean>;
+    /**
+     * 退出执行
+     * @param status 状态码
+    */
+    exit(status?: number): never;
+    /**
+     * 302 或 301 跳转
+     * @param url 要跳转的 url
+     * @param is301 是否采用 301 跳转
+     */
+    transfer(url: string, is301?: boolean): never;
+    /** 虚拟请求 */
+    request(method: Method, path: string, opt?: {
+        headers?: K99Request.Headers;
+        body?: K99Request.Reader | WriteType;
+    }): Promise<null | K99Response>;
+}
+
+declare class ExitSignal extends Error {
+    /**
+     * 忽略对退出信号的捕获
+     * @description 用于 try { } catch(e) {} 的 catch 中忽略退出信号
+     * @example
+     * try {
+     * 	doSomething();
+     * } catch (e) {
+     * 	ExitSignal.assert(e);
+     * 	customProcess(e);
+     * }
+     */
+    static assert(v: any): void;
+}
+
+/** 设置配置 */
+declare function setTest(test?: Handle<any>[typeof testSymbol]): <H extends Handle<any> | Handles<any>>(h: H) => H;
+/** 设置方法 */
+declare function setMethods(...methods: Method[]): <H extends Handle<any> | Handles<any>>(h: H) => H;
+/** 设置选项 */
+declare function setOptions(options?: Handle<any>[typeof optionsSymbol]): <H extends Handle<any> | Handles<any>>(h: H) => H;
+
+export { App, Assets, BaseWriteType, Context, Controller, CookieClearOption, CookieOption, CookieOptionInfo, ExitSignal, Exports, Guard, Handle, Handles, K99Request, K99Response, Log, Match, MaybePromise, Method, Plugin, PromiseValue, ResourceOption, Route, Router, Service, Settings, WriteType, catchSymbol, dataSymbol, finallySymbol, initSymbol, methodsSymbol, optionsSymbol, returnSymbol, setMethods, setOptions, setTest, testSymbol };