shokupan 0.7.0 → 0.10.0

package/dist/plugins/application/openapi/analyzer.impl.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Route information extracted from AST
+ */
+export interface RouteInfo {
+    method: string;
+    path: string;
+    handlerName?: string;
+    handlerSource?: string;
+    requestTypes?: {
+        body?: any;
+        query?: Record<string, string>;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    };
+    responseType?: string;
+    responseSchema?: any;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    operationId?: string;
+    emits?: {
+        event: string;
+        payload?: any;
+        location?: {
+            startLine: number;
+            endLine: number;
+        };
+    }[];
+    sourceContext?: {
+        file: string;
+        startLine: number;
+        endLine: number;
+        highlights?: {
+            startLine: number;
+            endLine: number;
+            type: 'emit' | 'return-success' | 'return-warning';
+        }[];
+    };
+}
+/**
+ * Dependency information
+ */
+interface DependencyInfo {
+    packageName: string;
+    version?: string;
+    importPath: string;
+    isExternal: boolean;
+}
+/**
+ * Application/Router instance found in code
+ */
+export interface ApplicationInstance {
+    name: string;
+    filePath: string;
+    className: 'Shokupan' | 'ShokupanRouter' | 'Controller';
+    controllerPrefix?: string;
+    routes: RouteInfo[];
+    mounted: MountInfo[];
+}
+interface MountInfo {
+    prefix: string;
+    target: string;
+    targetFilePath?: string;
+    dependency?: DependencyInfo;
+    sourceContext?: {
+        file: string;
+        startLine: number;
+        endLine: number;
+    };
+}
+/**
+ * Main analyzer class
+ */
+export declare class OpenAPIAnalyzer {
+    private rootDir;
+    private files;
+    private applications;
+    private program?;
+    private entrypoint?;
+    constructor(rootDir: string, entrypoint?: string);
+    /**
+     * Main analysis entry point
+     */
+    /**
+     * Main analysis entry point
+     */
+    analyze(): Promise<{
+        applications: ApplicationInstance[];
+    }>;
+    /**
+     * Remove GenericModules that are not mounted by any Shokupan application/router
+     */
+    private pruneApplications;
+    /**
+     * Recursively scan directory for TypeScript/JavaScript files
+     */
+    private scanDirectory;
+    /**
+     * Process source maps to reconstruct TypeScript
+     */
+    private processSourceMaps;
+    /**
+     * Parse TypeScript files and create AST
+     */
+    private parseTypeScriptFiles;
+    /**
+     * Find all Shokupan/ShokupanRouter instances
+     */
+    private findApplications;
+    /**
+     * Visit AST node to find application instances
+     */
+    private visitNode;
+    /**
+     * Extract route information from applications
+     */
+    private extractRoutes;
+    /**
+     * Extract routes from a Controller class
+     */
+    private extractRoutesFromController;
+    /**
+     * Extract routes from a specific file
+     */
+    private extractRoutesFromFile;
+    /**
+     * Extract route information from a route call (e.g., app.get('/path', handler))
+     */
+    private extractRouteFromCall;
+    /**
+     * Analyze a route handler to extract type information
+     */
+    private analyzeHandler;
+    /**
+     * Convert an Expression node to an OpenAPI schema (best effort)
+     */
+    private convertExpressionToSchema;
+    /**
+     * Check if an expression is a call to ctx.body()
+     */
+    private isCtxBodyCall;
+    /**
+     * Convert a TypeScript TypeNode to an OpenAPI schema
+     */
+    private convertTypeNodeToSchema;
+    /**
+     * Extract mount information from mount call
+     */
+    private extractMountFromCall;
+    /**
+     * Check if a reference is to an external dependency
+     */
+    private checkIfExternalDependency;
+    /**
+     * Get package version from package.json
+     */
+    private getPackageVersion;
+    /**
+     * Generate OpenAPI specification
+     */
+    generateOpenAPISpec(): any;
+}
+/**
+ * Analyze a directory and generate OpenAPI spec
+ */
+export declare function analyzeDirectory(directory: string): Promise<any>;
+export {};

package/dist/plugins/application/scalar.d.ts

@@ -21,6 +21,11 @@ export type ScalarPluginOptions = {
      * Only works with TypeScript entrypoints.
      */
     enableStaticAnalysis?: boolean;
+    /**
+     * Path to mount the plugin to.
+     * @default '/reference'
+     */
+    path?: string;
 };
 /**
  * Scalar plugin. This plugin provides an API reference interface for your API.
@@ -29,8 +34,10 @@ export type ScalarPluginOptions = {
  */
 export declare class ScalarPlugin extends ShokupanRouter<any> implements ShokupanPlugin {
     private readonly pluginOptions;
+    private eta;
     constructor(pluginOptions?: ScalarPluginOptions);
-    onInit(app: Shokupan, options?: ShokupanPluginOptions): void;
-    private init;
+    onInit(app: Shokupan, options?: ShokupanPluginOptions): Promise<void>;
+    private ensureEta;
+    private initRoutes;
     onMount(parent: ShokupanRouter<any>): void;
 }

package/dist/plugins/application/socket-io.d.ts

@@ -0,0 +1,14 @@
+import { Server } from 'socket.io';
+import { Shokupan } from '../../shokupan';
+/**
+ * Attaches the Shokupan HTTP Bridge and Event System to a Socket.IO server.
+ * This makes the Shokupan HTTP APIs accessible via Socket.IO events.
+ *
+ * Send events as `shokupan:request` events with the payload { type: "http", id: "123", body: {} }.
+ *
+ * Responses are emitted as `shokupan:response` events with the payload { id, status, body }
+ *
+ * @param io The Socket.IO server instance
+ * @param app The Shokupan application instance
+ */
+export declare function attachSocketIOBridge(io: Server, app: Shokupan): void;

package/dist/router.d.ts

@@ -1,5 +1,6 @@
 import { ShokupanContext } from './context';
 import { Shokupan } from './shokupan';
+import { SurrealDatastore } from './util/datastore';
 import { $appRoot, $childControllers, $childRouters, $isApplication, $isMounted, $isRouter, $mountPath, $parent, $routes } from './util/symbol';
 import { GuardAPISpec, HeadersInit, JSXRenderer, Method, MethodAPISpec, Middleware, OpenAPIOptions, ProcessResult, RequestOptions, RouteMetadata, RouteParams, ShokupanController, ShokupanHandler, ShokupanHooks, ShokupanRoute, ShokupanRouteConfig, StaticServeOptions } from './util/types';
 export declare const RouterRegistry: Map<string, ShokupanRouter<any>>;
@@ -73,69 +74,92 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     private [$parent];
     [$childRouters]: ShokupanRouter<T>[];
     [$childControllers]: ShokupanController[];
+    get db(): SurrealDatastore | undefined;
     private hookCache;
     private hooksInitialized;
     middleware: Middleware[];
-    get rootConfig(): {
-        [x: string]: any;
-        port?: number;
-        hostname?: string;
-        development?: boolean;
-        enableAsyncLocalStorage?: boolean;
-        enableOpenApiGen?: boolean;
-        reusePort?: boolean;
-        controllersOnly?: boolean;
+    get rootConfig(): Partial<{
+        [key: string]: any;
+        port: number;
+        hostname: string;
+        development: boolean;
+        enableAsyncLocalStorage: boolean;
+        enableOpenApiGen: boolean;
+        enableAsyncApiGen: boolean;
+        reusePort: boolean;
+        controllersOnly: boolean;
         enableTracing?: boolean;
         jsonParser?: "native" | "parse-json" | "secure-json-parse";
         autoBackpressureFeedback?: boolean;
         autoBackpressureLevel?: number;
-        enableMiddlewareTracking?: boolean;
+        enableMiddlewareTracking: boolean;
         middlewareTrackingMaxCapacity?: number;
+        enableHTTPBridge?: boolean;
+        websocketErrorHandler?: (err: any, ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
+        idGenerator?: () => string;
         middlewareTrackingTTL?: number;
-        httpLogger?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void;
-        logger?: {
-            verbose?: boolean;
-            info?: (msg: string, props: Record<string, any>) => void;
-            debug?: (msg: string, props: Record<string, any>) => void;
-            warning?: (msg: string, props: Record<string, any>) => void;
-            error?: (msg: string, props: Record<string, any>) => void;
-            fatal?: (msg: string, props: Record<string, any>) => void;
+        httpLogger: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void;
+        logger: {
+            verbose: boolean;
+            info: (msg: string, props: Record<string, any>) => void;
+            debug: (msg: string, props: Record<string, any>) => void;
+            warning: (msg: string, props: Record<string, any>) => void;
+            error: (msg: string, props: Record<string, any>) => void;
+            fatal: (msg: string, props: Record<string, any>) => void;
         };
-        readTimeout?: number;
-        requestTimeout?: number;
-        writeTimeout?: number;
-        renderer?: JSXRenderer;
-        serverFactory?: import('.').ServerFactory;
-        hooks?: {
-            onError?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, error: unknown) => void | Promise<void>;
-            onRequestStart?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onRequestEnd?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onResponseStart?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, response: Response) => void | Promise<void>;
-            onResponseEnd?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, response: Response) => void | Promise<void>;
-            beforeValidate?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, data: any) => void | Promise<void>;
-            afterValidate?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, data: any) => void | Promise<void>;
-            onReadTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onWriteTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onRequestTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-        } | {
-            onError?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, error: unknown) => void | Promise<void>;
-            onRequestStart?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onRequestEnd?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onResponseStart?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, response: Response) => void | Promise<void>;
-            onResponseEnd?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, response: Response) => void | Promise<void>;
-            beforeValidate?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, data: any) => void | Promise<void>;
-            afterValidate?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>, data: any) => void | Promise<void>;
-            onReadTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onWriteTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-            onRequestTimeout?: (ctx: ShokupanContext<Record<string, any>, Record<string, string>>) => void | Promise<void>;
-        }[];
-        validateStatusCodes?: boolean;
-    };
+        readTimeout: number;
+        requestTimeout: number;
+        writeTimeout: number;
+        renderer: JSXRenderer;
+        serverFactory: import('.').ServerFactory;
+        hooks: ShokupanHooks<Record<string, any>> | ShokupanHooks<Record<string, any>>[];
+        validateStatusCodes: boolean;
+        surreal?: {
+            engines?: import('surrealdb').Engines;
+            url?: string;
+            connectOptions?: import('surrealdb').ConnectOptions;
+            namespace?: string;
+            database?: string;
+        };
+        aiPlugin?: {
+            enabled?: boolean;
+            name_for_human?: string;
+            name_for_model?: string;
+            description_for_human?: string;
+            description_for_model?: string;
+            auth?: {
+                type: "none" | "service_http" | "user_http" | "oauth";
+                [key: string]: any;
+            };
+            api?: {
+                type: "openapi";
+                url?: string;
+                is_user_authenticated?: boolean;
+            };
+            logo_url?: string;
+            contact_email?: string;
+            legal_info_url?: string;
+        };
+        apiCatalog?: {
+            enabled?: boolean;
+            versions?: Array<{
+                name: string;
+                url: string;
+                spec_url: string;
+            }>;
+        };
+    }>;
     get root(): Shokupan<any>;
     [$routes]: ShokupanRoute[];
     private trie;
     metadata?: RouteMetadata;
     private currentGuards;
+    private eventHandlers;
+    /**
+     * Registers middleware for this router.
+     * Middleware will run for all routes matched by this router.
+     */
+    use(middleware: Middleware): this;
     getComponentRegistry(): {
         metadata: RouteMetadata;
         middleware: {
@@ -174,6 +198,18 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     };
     constructor(config?: ShokupanRouteConfig);
     private isRouterInstance;
+    /**
+     * Registers an event handler for WebSocket.
+     */
+    event(name: string, handler: ShokupanHandler<T>): this;
+    /**
+     * Finds an event handler(s) by name.
+     */
+    findEvent(name: string): ShokupanHandler<T>[] | null;
+    /**
+     * Returns all registered event handlers.
+     */
+    getEventHandlers(): Map<string, ShokupanHandler<T>[]>;
     /**
      * Mounts a controller instance to a path prefix.
      *
@@ -239,7 +275,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param arg.renderer - JSX renderer for the route
      * @param arg.controller - Controller for the route
      */
-    add({ method, path, spec, handler, regex: customRegex, group, requestTimeout, renderer, controller }: {
+    add({ method, path, spec, handler, regex: customRegex, group, requestTimeout, renderer, controller, metadata, middleware }: {
         method: Method;
         path: string;
         spec?: MethodAPISpec;
@@ -249,6 +285,11 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         requestTimeout?: number;
         renderer?: JSXRenderer;
         controller?: any;
+        metadata?: {
+            file: string;
+            line: number;
+        };
+        middleware?: Middleware[];
     }): this;
     /**
      * Adds a GET route to the router.
@@ -385,7 +426,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * Generates an OpenAPI 3.1 Document by recursing through the router and its descendants.
      * Now includes runtime analysis of handler functions to infer request/response types.
      */
-    generateApiSpec(options?: OpenAPIOptions): any;
+    generateApiSpec(options?: OpenAPIOptions): Promise<any>;
     private ensureHooksInitialized;
-    runHooks(name: keyof ShokupanHooks, ...args: any[]): Promise<void>;
+    runHooks(name: keyof ShokupanHooks, ...args: any[]): void | Promise<void[]>;
 }

package/dist/shokupan.d.ts

@@ -2,6 +2,7 @@ import { $dispatch } from './util/symbol';
 import { Middleware, ProcessResult, RequestOptions, ShokupanConfig, ShokupanPlugin } from './util/types';
 import { Server } from 'bun';
 import { ShokupanRouter } from './router';
+import { SurrealDatastore } from './util/datastore';
 import { ShokupanRequest } from './util/request';
 /**
  * Shokupan Application
@@ -70,17 +71,23 @@ import { ShokupanRequest } from './util/request';
 export declare class Shokupan<T = any> extends ShokupanRouter<T> {
     readonly applicationConfig: ShokupanConfig;
     openApiSpec?: any;
+    asyncApiSpec?: any;
     private composedMiddleware?;
     private cpuMonitor?;
+    private server?;
+    private datastore?;
+    dbPromise?: Promise<any>;
+    get db(): SurrealDatastore | undefined;
     get logger(): {
-        verbose?: boolean;
-        info?: (msg: string, props: Record<string, any>) => void;
-        debug?: (msg: string, props: Record<string, any>) => void;
-        warning?: (msg: string, props: Record<string, any>) => void;
-        error?: (msg: string, props: Record<string, any>) => void;
-        fatal?: (msg: string, props: Record<string, any>) => void;
+        verbose: boolean;
+        info: (msg: string, props: Record<string, any>) => void;
+        debug: (msg: string, props: Record<string, any>) => void;
+        warning: (msg: string, props: Record<string, any>) => void;
+        error: (msg: string, props: Record<string, any>) => void;
+        fatal: (msg: string, props: Record<string, any>) => void;
     };
     constructor(applicationConfig?: ShokupanConfig);
+    private initDatastore;
     /**
      * Adds middleware to the application.
      */
@@ -108,7 +115,26 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      * @param port - The port to listen on. If not specified, the port from the configuration is used. If that is not specified, port 3000 is used.
      * @returns The server instance.
      */
-    listen(port?: number): Promise<Server | import('http').Server<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>>;
+    listen(port?: number): Promise<Server<any>>;
+    /**
+     * Stops the application server.
+     *
+     * This method gracefully shuts down the server and stops any running monitors.
+     * Works transparently in both Bun and Node.js runtimes.
+     *
+     * @returns A promise that resolves when the server has been stopped.
+     *
+     * @example
+     * ```typescript
+     * const app = new Shokupan();
+     * const server = await app.listen(3000);
+     *
+     * // Later, when you want to stop the server
+     * await app.stop();
+     * ```
+     * @param closeActiveConnections — Immediately terminate in-flight requests, websockets, and stop accepting new connections.
+     */
+    stop(closeActiveConnections?: boolean): Promise<void>;
     [$dispatch](req: ShokupanRequest<T>): Promise<Response>;
     /**
      * Processes a request by wrapping the standard fetch method.
@@ -122,6 +148,6 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      * @param server - The server instance.
      * @returns The response to send.
      */
-    fetch(req: Request, server?: Server): Promise<Response>;
+    fetch(req: Request, server?: Server<any>): Promise<Response>;
     private handleRequest;
 }

package/dist/util/datastore.d.ts

@@ -1,6 +1,71 @@
-export declare const datastore: {
-    get<T extends Record<string, any>>(store: string, key: string): Promise<T>;
-    set(store: string, key: string, value: any): Promise<any>;
-    query(query: string, vars?: Record<string, unknown>): Promise<any>;
-    readonly ready: Promise<any>;
-};
+import { RecordId, Surreal, RecordIdRange, Table } from 'surrealdb';
+export declare class SurrealDatastore {
+    private readonly db;
+    constructor(db: Surreal);
+    createSchema(): void;
+    /**
+     * Select a record or contents of a table by its ID.
+     */
+    select<T = unknown>(id: RecordId | RecordIdRange | Table): Promise<(T extends object ? T extends {
+        id: infer Id;
+    } ? Id extends RecordId<string, import('surrealdb').RecordIdValue> ? T : Id extends import('surrealdb').RecordIdValue ? {
+        id: RecordId<string, Id>;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & T : {
+        id: RecordId;
+    }) extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
+    /**
+     * Merge update data into a record by its ID.
+     */
+    merge<T extends Record<string, any>>(id: RecordId, data: T): Promise<(T extends object ? T extends {
+        id: infer Id;
+    } ? Id extends RecordId<string, import('surrealdb').RecordIdValue> ? T : Id extends import('surrealdb').RecordIdValue ? {
+        id: RecordId<string, Id>;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & T : {
+        id: RecordId;
+    }) extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
+    /**
+     * Create a record by its ID.
+     */
+    create<T extends Record<string, any>>(id: RecordId, data: Omit<T, 'id'>): Promise<{
+        id: RecordId;
+    }>;
+    /**
+     * Upsert a record by its ID.
+     */
+    upsert<T extends Record<string, any>>(id: RecordId, data: T): Promise<(T extends object ? T extends {
+        id: infer Id;
+    } ? Id extends RecordId<string, import('surrealdb').RecordIdValue> ? T : Id extends import('surrealdb').RecordIdValue ? {
+        id: RecordId<string, Id>;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & Omit<T, "id"> : {
+        id: RecordId;
+    } & T : {
+        id: RecordId;
+    }) extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
+    /**
+     * Delete a record by its ID.
+     */
+    delete(id: RecordId): Promise<{
+        id: RecordId;
+    }>;
+    /**
+     * Run a SurrealDB query.
+     */
+    query<T extends Array<unknown>>(query: string, vars?: Record<string, any>): Promise<T extends [] ? unknown[] : { [K in keyof T]: T[K]; }>;
+    /**
+     * Create a relationship between two records.
+     */
+    relate(fromId: any, edgeId: any, toId: any, data?: Record<string, any>): Promise<{
+        [x: string]: /*elided*/ any;
+    }>;
+    disconnect(): Promise<true>;
+}

package/dist/util/decorators.d.ts

@@ -1,5 +1,5 @@
 import { RateLimitOptions } from '../plugins/middleware/rate-limit';
-import { GuardAPISpec, MethodAPISpec, Middleware } from './types';
+import { AsyncAPISpec, GuardAPISpec, MethodAPISpec, Middleware } from './types';
 /**
  * Class Decorator: Defines the base path for a controller.
  */
@@ -35,7 +35,7 @@ export declare const Ctx: (name?: string) => (target: any, propertyKey: string,
 /**
  * Decorator: Overrides the OpenAPI specification for a route.
  */
-export declare function Spec(spec: MethodAPISpec | GuardAPISpec): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Spec(spec: MethodAPISpec | GuardAPISpec | AsyncAPISpec): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 /**
  * Decorator: Binds a method to the GET HTTP verb.
  */
@@ -68,6 +68,11 @@ export declare const Head: (path?: string) => (target: any, propertyKey: string,
  * Decorator: Binds a method to ANY HTTP verb.
  */
 export declare const All: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Decorator: Binds a method to the WebSocket event.
+ * @param eventName The name of the event to listen for.
+ */
+export declare function Event(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 /**
  * Decorator: Applies a rate limit to a class or method.
  */

package/dist/util/http-error.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Standard HTTP Error class with status code.
+ * This standardizes on the `status` property instead of dual `status`/`statusCode`.
+ */
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/**
+ * Extracts HTTP status code from an error object.
+ * Supports both `status` and `statusCode` properties for backward compatibility.
+ * Defaults to 500 (Internal Server Error) if no status is found.
+ *
+ * @param err - Error object (may have `status` or `statusCode` property)
+ * @returns HTTP status code
+ */
+export declare function getErrorStatus(err: any): number;
+/**
+ * Common HTTP Errors
+ */
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string);
+}
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}
+export declare class InternalServerError extends HttpError {
+    constructor(message?: string);
+}
+export declare class EventError extends HttpError {
+    constructor(message?: string);
+}

package/dist/util/http-status.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Common HTTP Status Codes
+ * Use these constants instead of magic numbers for better readability
+ */
+export declare const HTTP_STATUS: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NO_CONTENT: 204;
+    readonly MOVED_PERMANENTLY: 301;
+    readonly FOUND: 302;
+    readonly SEE_OTHER: 303;
+    readonly NOT_MODIFIED: 304;
+    readonly TEMPORARY_REDIRECT: 307;
+    readonly PERMANENT_REDIRECT: 308;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly REQUEST_TIMEOUT: 408;
+    readonly CONFLICT: 409;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
 export declare const VALID_HTTP_STATUSES: Set<number>;
 export declare const VALID_REDIRECT_STATUSES: Set<number>;

package/dist/util/request.d.ts

@@ -2,7 +2,7 @@ import { Method } from './types';
 export type ShokupanRequestProps = {
     method: Method;
     url: string;
-    headers: Headers;
+    headers: Headers | Record<string, string>;
     body: any;
 };
 /**