@iskra-bun/web-kit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,966 @@
+import * as hono from 'hono';
+import { Hono, Context, Next, Handler } from 'hono';
+import { Driver, App, IskraError, ErrorCode } from '@iskra-bun/core';
+export { ErrorCode, ErrorCodes } from '@iskra-bun/core';
+import { z } from 'zod';
+import { HTTPException } from 'hono/http-exception';
+import { Auth as Auth$1 } from 'better-auth';
+import * as hono_utils_types from 'hono/utils/types';
+import { ErrorObject } from 'ajv';
+export { OpenAPIHono, createRoute, z } from '@hono/zod-openapi';
+
+/**
+ * Core microkernel orchestrator that manages features, dependencies, and application lifecycle.
+ */
+declare class Kernel {
+    private app;
+    private config;
+    private features;
+    private initialized;
+    constructor(config?: KernelConfig);
+    initialize(): Promise<void>;
+    private applySecurityHeaders;
+    registerFeature(feature: Feature): void;
+    private validateFeatureDependencies;
+    private validatePeerDependencies;
+    private sortFeaturesByDependencies;
+    private initializeFeature;
+    getApp(): Hono;
+    getFeature<T extends Feature>(name: string): T | undefined;
+    private server;
+    start(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+interface Sink {
+    (record: Record<string, unknown>): void;
+}
+interface KernelConfig {
+    port?: number;
+    hostname?: string;
+    environment?: "development" | "production" | "test";
+    securityHeaders?: SecurityHeadersConfig;
+}
+interface SecurityHeadersConfig {
+    contentSecurityPolicy?: string | {
+        directives?: Record<string, string | string[]>;
+    };
+    xFrameOptions?: "DENY" | "SAMEORIGIN" | string;
+    xContentTypeOptions?: boolean;
+    strictTransportSecurity?: {
+        maxAge?: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    };
+    xXssProtection?: boolean;
+    referrerPolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    permissionsPolicy?: Record<string, string[]>;
+}
+interface ApiKeyValidationResult {
+    isValid: boolean;
+    key?: ApiKeyMetadata;
+    error?: string;
+}
+interface ApiKeyMetadata {
+    id: string;
+    key: string;
+    name?: string;
+    scopes?: string[];
+    rateLimit?: {
+        max: number;
+        windowMs: number;
+    };
+    expiresAt?: Date;
+    createdAt: Date;
+    lastUsedAt?: Date;
+    metadata?: Record<string, any>;
+}
+interface ApiKeyConfig {
+    staticKeys?: Array<Partial<ApiKeyMetadata> & {
+        key: string;
+    }>;
+    headerName?: string;
+    queryParamName?: string;
+    extractStrategies?: ("header" | "bearer" | "query" | "custom")[];
+    vaultService?: any;
+    customExtractor?: (c: any) => string | null;
+    enableCache?: boolean;
+    cacheTtl?: number;
+    requireScopes?: boolean;
+    skipPaths?: string[];
+    onError?: (error: string, c: any) => Response | Promise<Response>;
+    onValidated?: (key: ApiKeyMetadata, c: any) => void | Promise<void>;
+}
+interface CsrfConfig {
+    secret: string;
+    cookieName?: string;
+    headerName?: string;
+    ignoreMethods?: string[];
+    cookieOptions?: {
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: "Strict" | "Lax" | "None";
+        maxAge?: number;
+    };
+}
+interface Feature {
+    name: string;
+    dependencies?: string[];
+    peerDependencies?: string[];
+    initialize(kernel: Kernel): Promise<void>;
+    routes?: (app: any) => void;
+    shutdown?(): Promise<void>;
+}
+interface CorsConfig {
+    origin?: string | string[] | ((origin: string) => boolean);
+    credentials?: boolean;
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    maxAge?: number;
+}
+interface RateLimitConfig {
+    windowMs?: number;
+    max?: number;
+    keyGenerator?: (c: any) => string;
+    skip?: (c: any) => boolean;
+    handler?: (c: any) => Response;
+    standardHeaders?: boolean;
+    store?: "memory" | "cache";
+}
+interface HealthCheckConfig {
+    path?: string;
+    readinessPath?: string;
+    livenessPath?: string;
+    includeDetails?: boolean;
+    checks?: {
+        [key: string]: (context?: any) => Promise<{
+            status: "ok" | "error";
+            message?: string;
+            details?: any;
+        }>;
+    };
+}
+interface RequestIdConfig {
+    headerName?: string;
+    generator?: () => string;
+}
+interface ErrorHandlerConfig {
+    includeStack?: boolean;
+    customHandlers?: {
+        [key: number]: (error: Error, c: any) => Response;
+    };
+    logger?: (error: Error, c: any) => void;
+}
+interface LoggerConfig {
+    level?: "debug" | "info" | "error" | "trace" | "warning" | "fatal" | null | undefined;
+    format?: "json" | "pretty";
+    sinks?: Array<{
+        type: "console" | "file";
+        path?: string;
+        level?: "debug" | "info" | "warn" | "error";
+    } | Sink>;
+    logRequests?: boolean;
+    logResponses?: boolean;
+}
+interface AuthConfig {
+    secret: string;
+    basePath?: string;
+    baseURL?: string;
+    trustedOrigins?: string[];
+    disableCSRFCheck?: boolean;
+    authMode?: "oidc" | "email";
+    enableSelfRegistration?: boolean;
+    socialProviders?: Record<string, any>;
+    oidcConfig?: {
+        clientId: string;
+        clientSecret: string;
+        issuer: string;
+        providerId?: string;
+        authorizationEndpoint?: string;
+        tokenEndpoint?: string;
+        userinfoEndpoint?: string;
+        jwksEndpoint?: string;
+        discoveryEndpoint?: string;
+        scopes?: string[];
+        pkce?: boolean;
+        mapping?: {
+            id?: string;
+            email?: string;
+            emailVerified?: string;
+            name?: string;
+            image?: string;
+            extraFields?: Record<string, string>;
+        };
+    };
+}
+interface SessionConfig {
+    store: "db" | "cache" | "memory";
+    secret: string;
+    ttl?: number;
+    cookieName?: string;
+    cookieOptions?: {
+        secure?: boolean;
+        sameSite?: "Strict" | "Lax" | "None";
+        domain?: string;
+        path?: string;
+    };
+}
+interface DbConfig {
+    adapter: "postgres" | "mysql" | "sqlite";
+    connection?: {
+        host?: string;
+        port?: number;
+        database?: string;
+        user?: string;
+        password?: string;
+        connectionString?: string;
+    };
+}
+interface CacheConfig {
+    adapter: "redis" | "memory";
+    connection?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+    };
+    secret?: string;
+    ttl?: number;
+}
+interface PermissionsConfig {
+    loadPermissions?: (userId: string) => Promise<string[]>;
+    loadRoles?: (userId: string) => Promise<string[]>;
+    anonymousPermissions?: string[];
+    enableRBAC?: boolean;
+    cachePermissions?: boolean;
+    cacheTTL?: number;
+}
+interface Role {
+    name: string;
+    permissions: string[];
+    description?: string;
+}
+interface OpenAPIConfig {
+    title: string;
+    version: string;
+    description?: string;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    tags?: Array<{
+        name: string;
+        description?: string;
+    }>;
+    contact?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+    };
+    externalDocs?: {
+        description: string;
+        url: string;
+    };
+    security?: Array<Record<string, string[]>>;
+    securitySchemes?: Record<string, any>;
+}
+interface UploadConfig {
+    projectName: string;
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    exposeRoutes?: boolean;
+    routePrefix?: string;
+}
+
+interface WebPluginConfig extends KernelConfig {
+    router?: Hono;
+    features?: Feature[];
+}
+declare class WebPlugin implements Driver {
+    name: string;
+    private app;
+    private kernel;
+    private runningServer;
+    private router?;
+    constructor(config?: WebPluginConfig);
+    init(app: App): Promise<void>;
+    getHonoApp(): Hono;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+interface RouteOptions<B = any, Q = any> {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    schema?: {
+        body?: z.ZodType<B>;
+        query?: z.ZodType<Q>;
+        params?: z.ZodType;
+    };
+    handler: (ctx: WebContext<B, Q>) => Promise<any> | any;
+    doc?: {
+        summary?: string;
+        tags?: string[];
+        description?: string;
+    };
+}
+interface WebContext<B = any, Q = any> {
+    raw: Context;
+    body: B;
+    query: Q;
+    params: Record<string, string>;
+    app: App;
+}
+declare const createRouter: (routes: RouteOptions[]) => RouteOptions<any, any>[];
+
+interface WebServerOptions {
+    port?: number;
+    routes?: RouteOptions[];
+    debug?: boolean;
+    openApi?: {
+        path: string;
+        title: string;
+        version: string;
+    };
+}
+declare class WebDriver implements Driver {
+    name: string;
+    private app;
+    private server;
+    private options;
+    private runningServer;
+    constructor(options?: WebServerOptions);
+    init(app: App): void;
+    private setupOpenApi;
+    private setupRoutes;
+    start(): void;
+    stop(): void;
+}
+
+declare class CorsFeature implements Feature {
+    private config;
+    name: string;
+    constructor(config?: CorsConfig);
+    initialize(kernel: Kernel): Promise<void>;
+}
+
+declare class ErrorHandlerFeature implements Feature {
+    name: string;
+    private config;
+    constructor(config?: ErrorHandlerConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private handleError;
+    private getStatusText;
+}
+declare function createHttpError(status: number, message: string): HTTPException;
+
+declare class HealthCheckFeature implements Feature {
+    name: string;
+    private kernel?;
+    private config;
+    constructor(config?: HealthCheckConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private handleHealthCheck;
+    private checkFeatureHealth;
+    private handleReadinessCheck;
+    private handleLivenessCheck;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        logger: any;
+    }
+}
+declare class LoggerFeature implements Feature {
+    name: string;
+    private config;
+    private logger;
+    constructor(config?: LoggerConfig);
+    initialize(kernel: Kernel): Promise<void>;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        requestId: string;
+    }
+}
+declare class RequestIdFeature implements Feature {
+    name: string;
+    private config;
+    constructor(config?: RequestIdConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private defaultGenerator;
+}
+
+interface StorageConfig {
+    adapter: "local" | "minio" | "s3";
+    basePath?: string;
+    connection?: {
+        endpoint?: string;
+        accessKey?: string;
+        secretKey?: string;
+        bucket?: string;
+        region?: string;
+        useSSL?: boolean;
+    };
+}
+interface StorageFile {
+    name: string;
+    path: string;
+    size: number;
+    mimeType?: string;
+    lastModified?: Date;
+    url?: string;
+}
+interface PutOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    public?: boolean;
+}
+interface StorageAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(path: string, expiresIn?: number): Promise<string>;
+    copy(from: string, to: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+    isDirectory(path: string): Promise<boolean>;
+}
+declare abstract class BaseStorageAdapter implements StorageAdapter {
+    protected connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
+    abstract get(path: string): Promise<Uint8Array | null>;
+    abstract delete(path: string): Promise<void>;
+    abstract exists(path: string): Promise<boolean>;
+    abstract list(prefix?: string): Promise<StorageFile[]>;
+    abstract url(path: string, expiresIn?: number): Promise<string>;
+    abstract isDirectory(path: string): Promise<boolean>;
+    isConnected(): boolean;
+    protected ensureConnected(): void;
+    copy(from: string, to: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+    protected generateFileName(originalName: string): string;
+    protected sanitizePath(path: string): string;
+    protected getMimeType(filename: string): string;
+}
+
+declare class LocalStorageAdapter extends BaseStorageAdapter {
+    private basePath;
+    constructor(config: StorageConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    put(filePath: string, data: Uint8Array | Buffer, options?: PutOptions): Promise<StorageFile>;
+    get(filePath: string): Promise<Uint8Array | null>;
+    delete(filePath: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    isDirectory(filePath: string): Promise<boolean>;
+    list(prefix?: string): Promise<StorageFile[]>;
+    url(filePath: string, _expiresIn?: number): Promise<string>;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        storage: BaseStorageAdapter;
+    }
+}
+declare class StorageFeature implements Feature {
+    private config;
+    name: string;
+    private adapter?;
+    constructor(config: StorageConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    shutdown(): Promise<void>;
+    getAdapter(): BaseStorageAdapter | undefined;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        db: any;
+    }
+}
+declare class DbFeature implements Feature {
+    private config;
+    name: string;
+    private client;
+    db: any;
+    readonly adapter: string;
+    constructor(config: DbConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+interface CacheAdapter {
+    get(key: string): Promise<any>;
+    set(key: string, value: any, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    increment?(key: string): Promise<number>;
+    disconnect?(): Promise<void>;
+}
+declare module "hono" {
+    interface ContextVariableMap {
+        cache: CacheAdapter;
+    }
+}
+declare class CacheFeature implements Feature {
+    private config;
+    name: string;
+    client: CacheAdapter;
+    constructor(config?: CacheConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        session: Record<string, any>;
+        sessionId: string;
+        destroySession: () => Promise<void>;
+    }
+}
+declare class SessionFeature implements Feature {
+    private config;
+    name: string;
+    dependencies?: string[];
+    private store?;
+    private ttl;
+    private cookieName;
+    constructor(config: SessionConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+interface BetterAuthConfigOptions {
+    db: any;
+    adapterType: "postgres" | "mysql" | "sqlite";
+    secret: string;
+    baseURL?: string;
+    basePath?: string;
+    trustedOrigins?: string[];
+    enableEmailPassword?: boolean;
+    disableCSRFCheck?: boolean;
+    socialProviders?: Record<string, any>;
+    oidcConfig?: {
+        clientId: string;
+        clientSecret: string;
+        issuer: string;
+        providerId?: string;
+        authorizationEndpoint?: string;
+        tokenEndpoint?: string;
+        userinfoEndpoint?: string;
+        jwksEndpoint?: string;
+        discoveryEndpoint?: string;
+        scopes?: string[];
+        pkce?: boolean;
+        mapping?: {
+            id?: string;
+            email?: string;
+            emailVerified?: string;
+            name?: string;
+            image?: string;
+            extraFields?: Record<string, string>;
+        };
+    };
+}
+declare function createBetterAuth(options: BetterAuthConfigOptions): Auth$1;
+type Auth = ReturnType<typeof createBetterAuth>;
+
+/**
+ * Auth feature types and interfaces
+ */
+interface User {
+    id: string;
+    email: string;
+    emailVerified: boolean;
+    name?: string | null;
+    image?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    [key: string]: any;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        user: User | null;
+        authUser: User | null;
+    }
+}
+declare class AuthFeature implements Feature {
+    name: string;
+    dependencies: string[];
+    private auth;
+    private config;
+    private kernel?;
+    private authMode;
+    constructor(config: AuthConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    routes(app: Hono): void;
+    getAuth(): Auth | undefined;
+}
+declare function requireAuth(kernel: Kernel): (c: Context, next: Next) => Promise<void>;
+
+declare class RateLimitFeature implements Feature {
+    name: string;
+    private config;
+    private store?;
+    private cleanupInterval?;
+    constructor(config?: RateLimitConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private middleware;
+    private defaultKeyGenerator;
+    shutdown(): Promise<void>;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        userPermissions: string[];
+        checkPermission: (permission: string) => boolean;
+        hasRole: (role: string) => boolean;
+        hasAnyRole: (...roles: string[]) => boolean;
+        hasAllRoles: (...roles: string[]) => boolean;
+    }
+}
+declare class PermissionsFeature implements Feature {
+    name: string;
+    dependencies: string[];
+    private config;
+    private roles;
+    constructor(config?: PermissionsConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private permissionsMiddleware;
+    private checkPermission;
+}
+declare function requirePermission(permission: string): (c: Context, next: Next) => Promise<void>;
+declare function requireRole(role: string): (c: Context, next: Next) => Promise<void>;
+
+declare class ApiKeyStore {
+    private config;
+    private kernel;
+    private staticKeysMap;
+    private cache?;
+    constructor(config: Required<ApiKeyConfig>, kernel: Kernel);
+    private getCache;
+    private initializeStaticKeys;
+    private generateId;
+    private compareKeys;
+    private isExpired;
+    validate(key: string): Promise<ApiKeyValidationResult>;
+    hasScopes(key: ApiKeyMetadata, requiredScopes: string[]): boolean;
+}
+declare module "hono" {
+    interface ContextVariableMap {
+        apiKey?: ApiKeyMetadata;
+        apiKeyScopes?: string[];
+        hasScope?: (scope: string) => boolean;
+        hasAnyScope?: (...scopes: string[]) => boolean;
+        hasAllScopes?: (...scopes: string[]) => boolean;
+    }
+}
+declare class ApiKeyFeature implements Feature {
+    name: string;
+    private store?;
+    private config;
+    constructor(config?: ApiKeyConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private shouldSkipPath;
+    private extractApiKey;
+}
+declare function requireApiKey(): (c: Context, next: Next) => Promise<void>;
+declare function requireScope(...scopes: string[]): (c: Context, next: Next) => Promise<void>;
+
+declare module "hono" {
+    interface ContextVariableMap {
+        csrfToken: string;
+    }
+}
+declare class CsrfFeature implements Feature {
+    name: string;
+    private config;
+    constructor(config: CsrfConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private middleware;
+    private validateToken;
+}
+declare function requireCsrf(): (c: Context, next: Next) => Promise<void>;
+
+declare module "hono" {
+    interface Context {
+        valid<T = any>(): T;
+    }
+}
+interface ValidationSchema {
+    params?: z.ZodSchema<any>;
+    query?: z.ZodSchema<any>;
+    body?: z.ZodSchema<any>;
+}
+interface ValidationOptions {
+    logErrors?: boolean;
+    status?: number;
+}
+declare function createValidationMiddleware(schema: ValidationSchema, options?: ValidationOptions): (c: Context, next: Next) => Promise<(Response & hono.TypedResponse<{
+    success: false;
+    error: string;
+    code?: string | undefined;
+    details?: hono_utils_types.JSONValue | undefined;
+    timestamp?: string | undefined;
+}, any, "json">) | undefined>;
+declare class ValidationFeature implements Feature {
+    name: string;
+    initialize(kernel: Kernel): Promise<void>;
+}
+
+declare module "hono" {
+    interface Hono {
+        getJsonValidated(path: string, schema: JsonValidationSchema, handler: Handler, options?: JsonValidationOptions): Hono;
+        postJsonValidated(path: string, schema: JsonValidationSchema, handler: Handler, options?: JsonValidationOptions): Hono;
+        putJsonValidated(path: string, schema: JsonValidationSchema, handler: Handler, options?: JsonValidationOptions): Hono;
+        deleteJsonValidated(path: string, schema: JsonValidationSchema, handler: Handler, options?: JsonValidationOptions): Hono;
+    }
+}
+interface JsonValidationSchema {
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+}
+interface JsonValidationOptions {
+    logErrors?: boolean;
+    status?: number;
+    allErrors?: boolean;
+    coerceTypes?: boolean;
+}
+interface FormattedValidationErrors {
+    fields: Record<string, string[]>;
+    errors: string[];
+}
+declare function formatAjvErrors(errors: ErrorObject[] | null | undefined): FormattedValidationErrors;
+declare function createJsonSchemaValidationMiddleware(schema: JsonValidationSchema, options?: JsonValidationOptions): (c: Context, next: Next) => Promise<(Response & hono.TypedResponse<{
+    success: false;
+    error: string;
+    code?: string | undefined;
+    details?: hono_utils_types.JSONValue | undefined;
+    timestamp?: string | undefined;
+}, any, "json">) | undefined>;
+declare class JsonSchemaValidationFeature implements Feature {
+    name: string;
+    initialize(kernel: Kernel): Promise<void>;
+}
+
+declare class OpenAPIFeature implements Feature {
+    name: string;
+    private app?;
+    private config;
+    private kernel?;
+    private autoGeneratedRoutes;
+    private queuedRoutes;
+    constructor(config: OpenAPIConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    addRoute(route: any, handler: Handler): void;
+    private processQueuedRoutes;
+    routes(app: Hono): void;
+    private generateScalarHTML;
+}
+
+interface UploadOptions {
+    metadata?: Record<string, string>;
+    contentType?: string;
+}
+interface UploadResult {
+    path: string;
+    filename: string;
+    size: number;
+    uploadedAt: Date;
+}
+declare class UploadHelper {
+    private storage;
+    private projectName;
+    private basePath;
+    constructor(storage: BaseStorageAdapter, projectName: string);
+    getBasePath(): string;
+    private buildPath;
+    upload(filename: string, data: Uint8Array | string, subfolder?: string, options?: UploadOptions): Promise<UploadResult>;
+    uploadFromRequest(request: Request, fieldName: string, subfolder?: string, options?: UploadOptions): Promise<UploadResult>;
+    list(subfolder?: string): Promise<StorageFile[]>;
+    get(filename: string, subfolder?: string): Promise<Uint8Array<ArrayBufferLike> | null>;
+    delete(filename: string, subfolder?: string): Promise<void>;
+    getUrl(filename: string, subfolder?: string, expiresIn?: number): Promise<string>;
+}
+
+declare module "hono" {
+    interface ContextVariableMap {
+        upload: UploadHelper;
+    }
+}
+declare class UploadFeature implements Feature {
+    name: string;
+    dependencies: string[];
+    private helper?;
+    private config;
+    constructor(config: UploadConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    routes(app: Hono): void;
+}
+
+interface OtelTracingConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    captureRequestHeaders?: string[];
+    captureResponseHeaders?: string[];
+    tracerProvider?: any;
+    meterProvider?: any;
+    tracer?: any;
+    spanNameFactory?: (c: any) => string;
+    getTime?: () => number;
+}
+declare class OtelTracingFeature implements Feature {
+    name: string;
+    private config;
+    constructor(config: OtelTracingConfig);
+    initialize(kernel: Kernel): Promise<void>;
+}
+
+interface EmailConfig {
+    provider: "smtp" | "sendgrid" | "mock" | "mailgun" | "ses";
+    smtp?: {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        secure?: boolean;
+    };
+    apiKey?: string;
+    apiSecret?: string;
+    region?: string;
+    domain?: string;
+    baseUrl?: string;
+    from?: {
+        name?: string;
+        email: string;
+    };
+    templateDir?: string;
+}
+interface EmailMessage {
+    to: string | string[];
+    from?: {
+        name?: string;
+        email: string;
+    };
+    subject: string;
+    text?: string;
+    html?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    attachments?: Array<{
+        filename: string;
+        content: Uint8Array | string;
+        contentType?: string;
+    }>;
+    headers?: Record<string, string>;
+}
+interface TemplateData {
+    [key: string]: unknown;
+}
+interface EmailAdapter {
+    send(message: EmailMessage): Promise<{
+        messageId: string;
+        success: boolean;
+    }>;
+    sendTemplate(templateName: string, to: string | string[], data: TemplateData): Promise<{
+        messageId: string;
+        success: boolean;
+    }>;
+}
+declare class MockEmailAdapter implements EmailAdapter {
+    send(message: EmailMessage): Promise<{
+        messageId: string;
+        success: boolean;
+    }>;
+    sendTemplate(name: string, to: string | string[], data: TemplateData): Promise<{
+        messageId: string;
+        success: boolean;
+    }>;
+}
+declare module "hono" {
+    interface ContextVariableMap {
+        email: EmailAdapter;
+    }
+}
+declare class EmailFeature implements Feature {
+    private config;
+    name: string;
+    private adapter?;
+    constructor(config: EmailConfig);
+    initialize(kernel: Kernel): Promise<void>;
+    private createAdapter;
+    getAdapter(): EmailAdapter;
+}
+
+interface SuccessResponse<T = unknown> {
+    success: true;
+    data?: T;
+    message?: string;
+}
+interface ErrorResponse {
+    success: false;
+    error: string;
+    code?: string;
+    details?: unknown;
+    timestamp?: string;
+}
+type ApiResponse<T = unknown> = SuccessResponse<T> | ErrorResponse;
+declare function successResponse<T = unknown>(data?: T, message?: string): SuccessResponse<T>;
+declare function errorResponse(error: string | Error, code?: string, details?: unknown): ErrorResponse;
+
+declare class HttpError extends IskraError {
+    readonly status: number;
+    constructor(status: number, message: string, options?: {
+        code?: ErrorCode;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    toHTTPException(): HTTPException;
+}
+declare class ValidationError extends HttpError {
+    readonly details: unknown;
+    constructor(message: string, details?: unknown, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class AuthError extends HttpError {
+    constructor(message?: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class ForbiddenError extends HttpError {
+    constructor(message?: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class NotFoundError extends HttpError {
+    constructor(message?: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class ConflictError extends HttpError {
+    constructor(message?: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+
+export { type ApiKeyConfig, ApiKeyFeature, type ApiKeyMetadata, ApiKeyStore, type ApiKeyValidationResult, type ApiResponse, type AuthConfig, AuthError, AuthFeature, BaseStorageAdapter, type CacheAdapter, type CacheConfig, CacheFeature, ConflictError, type CorsConfig, CorsFeature, type CsrfConfig, CsrfFeature, type DbConfig, DbFeature, type EmailAdapter, type EmailConfig, EmailFeature, type EmailMessage, type ErrorHandlerConfig, ErrorHandlerFeature, type ErrorResponse, type Feature, ForbiddenError, type FormattedValidationErrors, type HealthCheckConfig, HealthCheckFeature, HttpError, JsonSchemaValidationFeature, type JsonValidationOptions, type JsonValidationSchema, Kernel, type KernelConfig, LocalStorageAdapter, type LoggerConfig, LoggerFeature, MockEmailAdapter, NotFoundError, type OpenAPIConfig, OpenAPIFeature, type OtelTracingConfig, OtelTracingFeature, type PermissionsConfig, PermissionsFeature, type RateLimitConfig, RateLimitFeature, type RequestIdConfig, RequestIdFeature, type Role, type RouteOptions, type SecurityHeadersConfig, type SessionConfig, SessionFeature, type Sink, type StorageConfig, StorageFeature, type StorageFile, type SuccessResponse, type TemplateData, type UploadConfig, UploadFeature, ValidationError, ValidationFeature, type ValidationOptions, type ValidationSchema, type WebContext, WebDriver, WebPlugin, type WebPluginConfig, type WebServerOptions, createHttpError, createJsonSchemaValidationMiddleware, createRouter, createValidationMiddleware, errorResponse, formatAjvErrors, requireApiKey, requireAuth, requireCsrf, requirePermission, requireRole, requireScope, successResponse };