@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/router/file-based-routing.d.ts

@@ -1,40 +0,0 @@
-import type { EnhancedRequest } from '../types';
-import type { Router } from './router';
-export type { DiscoveredRoute };
-/**
- * Registers file-based routing extension on the Router class
- */
-export declare function registerFileBasedRouting(RouterClass: typeof Router): void;
-/**
- * File-based routing configuration
- */
-export declare interface FileBasedRoutingConfig {
-  enabled?: boolean
-  viewsPath?: string
-  extensions?: string[]
-  exclude?: string[]
-  render?: (filePath: string, data: Record<string, unknown>, request: EnhancedRequest) => Promise<Response>
-}
-declare interface DiscoveredRoute {
-  filePath: string
-  routePath: string
-  params: string[]
-  isIndex: boolean
-  isDynamic: boolean
-}
-// Type augmentation for Router
-declare module './router' {
-  interface Router {
-  _viewsDir?: string | null
-  _fileRoutingConfig?: FileBasedRoutingConfig | null
-  _fileBasedRoutes?: DiscoveredRoute[]
-  _fileRoutesInitialized?: boolean
-  _initFileRoutes(): Promise<void>
-  views(config: FileBasedRoutingConfig | string): Router
-  disableFileRouting(): Router
-  getFileRoutes(): DiscoveredRoute[]
-  fileRoutes(viewsPath?: string, options?: Omit<FileBasedRoutingConfig, 'viewsPath'>): Promise<Router>
-  loadFileRoutes(config?: FileBasedRoutingConfig): Promise<Router>
-}
-}
-export { detectViewsDirectory, discoverRoutes, DEFAULT_VIEW_DIRECTORIES, DEFAULT_EXCLUDES, DEFAULT_EXTENSIONS };

package/dist/router/file-streaming.d.ts

@@ -1,6 +0,0 @@
-import type {  } from '../types';
-import type { Router } from './router';
-/**
- * File streaming extension for Router class
- */
-export declare function registerFileStreaming(RouterClass: typeof Router): void;

package/dist/router/fluent-router.d.ts

@@ -1,179 +0,0 @@
-import type { ActionHandler, EnhancedRequest, MiddlewareHandler, Route, RouteHandler,  } from '../types';
-import type { Router } from './router';
-/**
- * Extend Router with fluent routing methods
- */
-export declare function registerFluentRouting(RouterClass: typeof import('./router').Router): void;
-/**
- * Controller class interface
- */
-export declare interface ControllerClass {
-  new (): Controller
-}
-/**
- * Base controller interface
- */
-export declare interface Controller {
-
-}
-/**
- * Resource configuration
- */
-export declare interface ResourceOptions {
-  only?: ResourceMethod[]
-  except?: ResourceMethod[]
-  middleware?: (string | MiddlewareHandler)[]
-  names?: Partial<Record<ResourceMethod, string>>
-  parameters?: Record<string, string>
-  shallow?: boolean
-}
-/**
- * Route builder for fluent API
- */
-export declare interface FluentRoute {
-  name: (name: string) => FluentRoute
-  middleware: (...middleware: (string | MiddlewareHandler)[]) => FluentRoute
-  withoutMiddleware: (...middleware: string[]) => FluentRoute
-  where: (param: string, pattern: string | RegExp) => FluentRoute
-  whereNumber: (param: string) => FluentRoute
-  whereAlpha: (param: string) => FluentRoute
-  whereAlphaNumeric: (param: string) => FluentRoute
-  whereUuid: (param: string) => FluentRoute
-  whereSlug: (param: string) => FluentRoute
-  can: (ability: string, model?: string) => FluentRoute
-  missing: (handler: (req: EnhancedRequest) => Response) => FluentRoute
-  withTrashed: () => FluentRoute
-  scopeBindings: () => FluentRoute
-}
-/**
- * Group builder for fluent API
- */
-export declare interface GroupBuilder {
-  prefix: (prefix: string) => GroupBuilder
-  name: (name: string) => GroupBuilder
-  middleware: (...middleware: (string | MiddlewareHandler)[]) => GroupBuilder
-  domain: (domain: string) => GroupBuilder
-  controller: (controller: ControllerClass) => GroupBuilder
-  routes: (callback: (router: FluentRouter) => void) => void
-}
-declare interface GroupOptions {
-  prefix?: string
-  as?: string
-  middleware?: (string | MiddlewareHandler)[]
-  domain?: string
-  controller?: ControllerClass
-}
-/**
- * Resource controller methods
- */
-export type ResourceMethod = 'index' | 'create' | 'store' | 'show' | 'edit' | 'update' | 'destroy'
-/**
- * API resource methods (no create/edit views)
- */
-export type ApiResourceMethod = 'index' | 'store' | 'show' | 'update' | 'destroy'
-/**
- * Singleton resource methods
- */
-export type SingletonMethod = 'show' | 'edit' | 'update'
-/**
- * Fluent router with chainable API
- */
-export declare class FluentRouter {
-  private router: Router;
-  private currentPrefix: string;
-  private currentNamePrefix: string;
-  private currentMiddleware: (string | MiddlewareHandler)[];
-  private currentDomain: string | null;
-  private currentController: ControllerClass | null;
-  private excludedMiddleware: Set<string>;
-  constructor(router: Router);
-  get(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  post(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  put(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  patch(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  delete(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  options(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  any(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  match(methods: string[], path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  resource(name: string, Controller: ControllerClass, options?: ResourceOptions): this;
-  apiResource(name: string, controller: ControllerClass, options?: ResourceOptions): this;
-  singleton(name: string, Controller: ControllerClass, options?: ResourceOptions): this;
-  prefix(prefix: string): GroupBuilderImpl;
-  name(namePrefix: string): GroupBuilderImpl;
-  middleware(middleware: (string | MiddlewareHandler)[]): GroupBuilderImpl;
-  domain(domain: string): GroupBuilderImpl;
-  controller(controller: ControllerClass): GroupBuilderImpl;
-  group(options: GroupOptions, callback: (router: FluentRouter) => void): this;
-  has(name: string): boolean;
-  current(): Route | null;
-  currentRouteName(): string | null;
-  route(name: string, params?: Record<string, string | number>): string;
-  fallback(handler: RouteHandler): this;
-  private addRoute(method: string, path: string, handler: RouteHandler | string): FluentRouteBuilder;
-  private createPattern(routePath: string): { exec: (url: URL) => { pathname: { groups: Record<string, string> } } | null };
-  private buildPath(path: string): string;
-  private buildMiddleware(additional?: (string | MiddlewareHandler)[]): MiddlewareHandler[];
-  private resolveHandler(handler: RouteHandler | string): ActionHandler;
-  private resolveMiddleware(middleware: string | MiddlewareHandler): MiddlewareHandler;
-  private getResourceMethods(options: ResourceOptions): ResourceMethod[];
-  private getResourceRoute(name: string, method: ResourceMethod, paramName: string): { httpMethod: string, path: string, handlerName: string };
-  private getSingletonRoute(name: string, method: SingletonMethod): { httpMethod: string, handlerName: string };
-}
-/**
- * Fluent route builder for chaining route configuration
- */
-export declare class FluentRouteBuilder implements FluentRoute {
-  private router: Router;
-  private path: string;
-  private method: string;
-  private routeName: string | null;
-  private routeMiddleware: MiddlewareHandler[];
-  private excludedMiddleware: string[];
-  private constraints: Record<string, string | RegExp>;
-  private missingHandler: ((req: EnhancedRequest) => Response) | null;
-  private includeTrashed: boolean;
-  private scopeBindingsEnabled: boolean;
-  private ability: string | null;
-  private abilityModel: string | null;
-  constructor(router: Router, path: string, method: string);
-  name(name: string): this;
-  middleware(middleware: (string | MiddlewareHandler)[]): this;
-  withoutMiddleware(middleware: string[]): this;
-  where(param: string, pattern: string | RegExp): this;
-  whereNumber(param: string): this;
-  whereAlpha(param: string): this;
-  whereAlphaNumeric(param: string): this;
-  whereUuid(param: string): this;
-  whereSlug(param: string): this;
-  can(ability: string, model?: string): this;
-  missing(handler: (req: EnhancedRequest) => Response): this;
-  withTrashed(): this;
-  scopeBindings(): this;
-  private findRoute(): Route | undefined;
-}
-declare class GroupBuilderImpl implements GroupBuilder {
-  private fluentRouter: FluentRouter;
-  private options: GroupOptions;
-  constructor(router: FluentRouter);
-  prefix(prefix: string): this;
-  name(name: string): this;
-  middleware(middleware: (string | MiddlewareHandler)[]): this;
-  domain(domain: string): this;
-  controller(controller: ControllerClass): this;
-  routes(callback: (router: FluentRouter) => void): void;
-}
-// ============================================================================
-// Type Augmentation
-// ============================================================================
-declare module './router' {
-  interface Router {
-  fluent: () => FluentRouter
-  resourceController: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router
-  apiResourceController: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router
-  singletonResource: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router
-  hasRoute: (name: string) => boolean
-  currentRoute: () => Route | null
-  currentRouteName: () => string | null
-  routeUrl: (name: string, params?: Record<string, string | number>) => string
-}
-}

package/dist/router/fluent-routing.d.ts

@@ -1,198 +0,0 @@
-import { RouteCacheFactory } from '../routing/route-caching';
-import { ThrottleFactory } from '../routing/route-throttling';
-import type { BunQueryBuilderModel } from '../model-binding';
-import type { EnhancedRequest, MiddlewareHandler, RouteHandler, ThrottlePattern } from '../types';
-import type { RouteCacheConfig } from '../routing/route-caching';
-import type { ThrottleConfig } from '../routing/route-throttling';
-/**
- * Factory functions for common route patterns
- */
-export declare const RouteFactory: {
-  api: (path: string, handler: RouteHandler, options?: ApiRouteOptions) => FluentRouteBuilder
-  protected: (path: string, handler: RouteHandler, options?: ProtectedRouteOptions) => FluentRouteBuilder
-  upload: (path: string, handler: RouteHandler, options?: UploadRouteOptions) => FluentRouteBuilder
-};
-/**
- * Utility functions
- */
-export declare const RouterUtils: {
-  /**
-   * Generate route URL with parameters
-   */
-  route: (name: string, params: Record<string, string> = {}, query: Record<string, string> = {}) => any;
-  /**
-   * Redirect response
-   */
-  redirect: (url: string, status: number?) => any;
-  /**
-   * JSON response
-   */
-  json: (data: any, status: number?) => any
-};
-/**
- * Global router instance
- */
-export declare const router: FluentRouter;
-/**
- * Conditional middleware wrapper
- */
-export declare interface ConditionalMiddleware {
-  condition: MiddlewareCondition
-  middleware: MiddlewareHandler[]
-}
-/** API route options */
-export declare interface ApiRouteOptions {
-  method?: string
-  cache?: string[]
-  throttle?: string
-}
-/** Protected route options */
-export declare interface ProtectedRouteOptions {
-  method?: string
-  roles?: string[]
-}
-/** Upload route options */
-export declare interface UploadRouteOptions {
-  maxSize?: number
-  allowedTypes?: string[]
-}
-/**
- * Middleware condition function type
- */
-export type MiddlewareCondition = (request: EnhancedRequest) => boolean | Promise<boolean>
-/**
- * Fluent route builder with chainable API
- */
-export declare class FluentRouteBuilder {
-  private middleware: MiddlewareHandler[];
-  private cacheConfig?: RouteCacheConfig;
-  private throttleConfig?: ThrottleConfig;
-  private routeName?: string;
-  private modelBindings: Record<string, BunQueryBuilderModel>;
-  private method: string;
-  private path: string;
-  private handler: RouteHandler;
-  constructor(method: string, path: string, handler: RouteHandler);
-  addMiddleware(middleware: MiddlewareHandler | MiddlewareHandler[]): this;
-  cached(tags?: string[], config?: Partial<RouteCacheConfig>): this;
-  throttle(limit: ThrottlePattern | ThrottleConfig, _name?: string): this;
-  name(name: string): this;
-  model(parameter: string, model: BunQueryBuilderModel): this;
-  build(): {
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware: MiddlewareHandler[]
-    name?: string
-  };
-}
-/**
- * Builder for conditional middleware
- */
-export declare class FluentConditionalBuilder {
-  private router: FluentRouter;
-  private condition: MiddlewareCondition;
-  constructor(router: FluentRouter, condition: MiddlewareCondition);
-  middleware(middlewareName: string): this;
-}
-/**
- * Builder for middleware with parameters
- */
-export declare class FluentMiddlewareBuilder {
-  private router: FluentRouter;
-  private middleware: MiddlewareHandler[];
-  constructor(router: FluentRouter, middleware: MiddlewareHandler[]);
-  get(path: string, handler: RouteHandler): FluentRouteBuilder;
-  post(path: string, handler: RouteHandler): FluentRouteBuilder;
-  put(path: string, handler: RouteHandler): FluentRouteBuilder;
-  delete(path: string, handler: RouteHandler): FluentRouteBuilder;
-  patch(path: string, handler: RouteHandler): FluentRouteBuilder;
-}
-/**
- * Builder for route groups with middleware
- */
-export declare class FluentRouteGroupBuilder {
-  private router: FluentRouter;
-  private groupMiddleware: MiddlewareHandler[];
-  constructor(router: FluentRouter, groupMiddleware: MiddlewareHandler[]);
-  get(path: string, handler: RouteHandler): FluentRouteBuilder;
-  post(path: string, handler: RouteHandler): FluentRouteBuilder;
-  put(path: string, handler: RouteHandler): FluentRouteBuilder;
-  delete(path: string, handler: RouteHandler): FluentRouteBuilder;
-  patch(path: string, handler: RouteHandler): FluentRouteBuilder;
-}
-/**
- * Fluent router with chainable API and advanced features
- */
-export declare class FluentRouter {
-  private routes: Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware: MiddlewareHandler[]
-    name?: string
-  }>;
-  private globalMiddleware: MiddlewareHandler[];
-  private subdomainRouter: any;
-  private routeGroups: Array<{
-    prefix?: string
-    middleware?: MiddlewareHandler[]
-    name?: string
-    domain?: string
-  }>;
-  private middlewareGroups: any;
-  private namedMiddleware: any;
-  private conditionalMiddleware: ConditionalMiddleware[];
-  constructor();
-  private setupDefaultMiddleware(): void;
-  middlewareGroup(name: string, middlewareNames: string[]): this;
-  middlewareGroupRoutes(name: string): FluentRouteGroupBuilder;
-  when(condition: MiddlewareCondition): FluentConditionalBuilder;
-  middleware(middlewareName: string): FluentMiddlewareBuilder;
-  use(middleware: MiddlewareHandler): this;
-  get(path: string, handler: RouteHandler): FluentRouteBuilder;
-  post(path: string, handler: RouteHandler): FluentRouteBuilder;
-  put(path: string, handler: RouteHandler): FluentRouteBuilder;
-  delete(path: string, handler: RouteHandler): FluentRouteBuilder;
-  patch(path: string, handler: RouteHandler): FluentRouteBuilder;
-  register(builder: FluentRouteBuilder): this;
-  cached(tags?: string[], config?: Partial<RouteCacheConfig>): {
-    get: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    post: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    put: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    delete: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    patch: (path: string, handler: RouteHandler) => FluentRouteBuilder
-  };
-  throttled(limit: ThrottlePattern | ThrottleConfig): {
-    get: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    post: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    put: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    delete: (path: string, handler: RouteHandler) => FluentRouteBuilder
-    patch: (path: string, handler: RouteHandler) => FluentRouteBuilder
-  };
-  group(config: {
-      prefix?: string
-      middleware?: MiddlewareHandler[]
-      name?: string
-      domain?: string
-    }, callback: (router: FluentRouter) => void): this;
-  domain(pattern: string): {
-    routes: (callback: (router: FluentRouter) => void) => FluentRouter
-  };
-  resource(name: string, controller: any, options?: {
-    only?: string[]
-    except?: string[]
-    model?: BunQueryBuilderModel
-  }): this;
-  getRoutes(): Array<{
-    method: string
-    path: string
-    handler: RouteHandler
-    middleware: MiddlewareHandler[]
-    name?: string
-  }>;
-  handle(request: EnhancedRequest): Promise<Response | null>;
-  private matchesRoute(route: any, request: EnhancedRequest): boolean;
-  private executeRoute(route: any, request: EnhancedRequest): Promise<Response>;
-}
-export { RouteCacheFactory, ThrottleFactory };

package/dist/router/group-organization.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * Route grouping and organization extension for Router class
- */
-export declare function registerGroupOrganization(RouterClass: typeof Router): void;

package/dist/router/handler-resolver.d.ts

@@ -1,13 +0,0 @@
-import type { EnhancedRequest, RouterConfig } from '../types';
-/**
- * Wraps a value in a Response object if it's not already a Response
- */
-export declare function wrapResponse(value: unknown): Response;
-/**
- * Resolves and executes a handler, returning a Response
- */
-export declare function resolveHandler(handler: unknown, req: EnhancedRequest, config: RouterConfig): Promise<Response>;
-/**
- * Creates a handler resolver bound to a specific config
- */
-export declare function createHandlerResolver(config: RouterConfig): (handler: unknown, req: EnhancedRequest) => Promise<Response>;

package/dist/router/http-methods.d.ts

@@ -1,10 +0,0 @@
-import type { Router } from './router';
-/**
- * HTTP methods extension for Router class
- * Uses a class extension pattern instead of prototype manipulation
- */
-export declare function registerHttpMethods(RouterClass: typeof Router): void;
-/**
- * Register redirect methods on the Router class
- */
-export declare function registerRedirectMethods(RouterClass: typeof Router): void;

package/dist/router/index.d.ts

@@ -1,114 +0,0 @@
-import { Dependencies, globalMiddlewarePipeline, MiddlewareFactory, MiddlewarePipeline, SkipConditions } from '../middleware/pipeline';
-import { FluentRouteBuilder, FluentRouter, RouteFactory, router, RouterUtils } from './fluent-routing';
-import { Router } from './router';
-import type { ActionHandler, Route } from '../types';
-export type { DiscoveredRoute, FileBasedRoutingConfig } from './file-based-routing';
-// Type augmentation for Laravel-style methods
-declare module './router' {
-  interface Router {
-  stream: (
-      callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>,
-      status?: number,
-      headers?: Record<string, string>
-    ) => Response
-  streamJson: <T>(
-      data: Record<string, Iterable<T> | AsyncIterable<T>>,
-      status?: number,
-      headers?: Record<string, string>
-    ) => Response
-  eventStream: <_T = any>(
-      callback: () => Generator<{ data: any, event?: string, id?: string, retry?: number }, void, unknown> | AsyncGenerator<{ data: any, event?: string, id?: string, retry?: number }, void, unknown>,
-      headers?: Record<string, string>
-    ) => Response
-  streamDownload: (
-      callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>,
-      filename: string,
-      headers?: Record<string, string>
-    ) => Response
-  streamFile: (
-      filePath: string,
-      request: any,
-      options?: {
-        contentType?: string
-        enableRanges?: boolean
-        chunkSize?: number
-      }
-    ) => Promise<Response>
-  streamFileWithRanges: (filePath: string, req: any) => Promise<Response>
-  streamResponse: (
-      generator: () => AsyncGenerator<string | Uint8Array, void, unknown>,
-      options?: { headers?: Record<string, string>, status?: number }
-    ) => Response
-  transformStream: (
-      transformer: (chunk: string | Uint8Array) => string | Uint8Array | Promise<string | Uint8Array>,
-      options?: { headers?: Record<string, string>, status?: number }
-    ) => (req: Request) => Response
-  model: <T>(
-      key: string,
-      modelClass: string | ((value: string) => Promise<T | null>),
-      callback?: (model: T | null) => Response | null
-    ) => Router
-  implicitBinding: () => any
-  missing: (callback: (req: any) => Response) => any
-  scopedBindings: (bindings: Record<string, string>) => any
-  clearModelCache: (modelName?: string) => Router
-  getModelStats: () => {
-      totalEntries: number
-      validEntries: number
-      expiredEntries: number
-      models: number
-    }
-  modelRegistry: {
-      has: (name: string) => boolean
-      register: <_T>(name: string, config: any) => void
-      resolve: <_T>(modelName: string, params: Record<string, string>, req?: any) => Promise<any>
-      createErrorResponse: (modelName: string, result: any, params: Record<string, string>) => Response
-      clearCache: (modelName: string, params?: Record<string, string>) => void
-      clearAllCache: () => void
-      getCacheStats: () => any
-    }
-  matchRoute: (path: string, method: string, domain?: string) => { route: Route, params: Record<string, string> } | undefined
-  getAllowedMethods: (path: string, domain?: string) => string[]
-  clearRouteCache: () => void
-  getCacheStats: () => any
-  getRouteStats: () => any
-  warmRouteCache: (commonPaths: Array<{ path: string, method: string }>) => void
-  getRoutesByMethod: () => any
-  getRouteConflicts: () => any
-  rebuildRouteCompiler: () => void
-  optimizeRoutes: (usageStats?: Record<string, number>) => void
-  addRouteToCompiler: (route: Route) => void
-  initializeRouteCompiler: () => void
-  health: () => Promise<Router>
-  renderView: (view: string, data?: Record<string, any>, options?: { layout?: string }) => Promise<string>
-  view: (path: string, view: string, data?: Record<string, any>, options?: { layout?: string, status?: number, headers?: Record<string, string> }) => Promise<Router>
-  where: ((param: string, pattern: string | RegExp) => Router) & ((constraints: Record<string, string | RegExp>) => Router)
-  whereNumber: (param: string) => Router
-  whereAlpha: (param: string) => Router
-  whereAlphaNumeric: (param: string) => Router
-  whereUuid: (param: string) => Router
-  whereIn: (param: string, values: string[]) => Router
-  domain: (domain: string, callback: () => Promise<void> | void) => Promise<Router>
-  resource: (name: string, handlers: {
-      index?: ActionHandler
-      show?: ActionHandler
-      store?: ActionHandler
-      update?: ActionHandler
-      destroy?: ActionHandler
-      create?: ActionHandler
-      edit?: ActionHandler
-    }) => Promise<Router>
-  onError: (handler: (error: Error) => Response | Promise<Response>) => Router
-  redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response
-  permanentRedirect: (url: string) => Response
-  fallback: (handler: ActionHandler) => Router
-  route: (name: string, params?: Record<string, string>) => string
-}
-}
-export { Router };
-export { Dependencies, FluentRouteBuilder, FluentRouter, globalMiddlewarePipeline, MiddlewareFactory, MiddlewarePipeline, RouteFactory, router, RouterUtils, SkipConditions };
-export * from '../routing/route-caching';
-export * from '../routing/route-throttling';
-export * from '../routing/subdomain-routing';
-export { createHandlerResolver, resolveHandler, wrapResponse } from './handler-resolver';
-export * from './validation-integration';

package/dist/router/middleware-integration.d.ts

@@ -1,86 +0,0 @@
-import type { EnhancedRequest, MiddlewareHandler } from '../types';
-import type { Router } from './router';
-/**
- * Integration layer for middleware pipeline with the router
- */
-export declare function registerMiddlewarePipeline(RouterClass: typeof Router): void;
-/**
- * Helper function to setup common middleware stack
- */
-export declare function setupMiddlewareStack(router: any, options?: {
-  auth?: {
-    jwtSecret: string
-    skipPaths?: string[]
-    requireRoles?: string[]
-  }
-  rateLimit?: {
-    maxRequests: number
-    windowMs: number
-    skipPaths?: string[]
-  }
-  cors?: {
-    origin?: string | string[]
-    methods?: string[]
-    allowedHeaders?: string[]
-    credentials?: boolean
-  }
-  logging?: {
-    level?: string
-    skipPaths?: string[]
-  }
-}): MiddlewareHandler[];
-/**
- * Skip condition helpers
- */
-export declare const SkipConditions: {
-  skipForPaths: (paths: string[]) => any;
-  skipForMethods: (methods: string[]) => any
-};
-/**
- * Dependency helpers
- */
-export declare const Dependencies: {
-  cache: (config: { type: string, ttl: number }) => unknown;
-  logger: (level: string) => unknown
-};
-// Type placeholders for middleware pipeline
-export type SkipConditionFn = (req: EnhancedRequest) => boolean
-export type SkipConditionsList = SkipConditionFn[]
-declare class MiddlewarePipeline {
-  registerDependency(_key: string, _dependency: any): this;
-  registerSkipConditions(_middleware: MiddlewareHandler, _conditions: SkipConditionsList): void;
-  getStats(): any;
-  getCacheInfo(): any;
-  clearCache(): this;
-  compilePipeline(_key: string, _middleware: MiddlewareHandler[], _options?: any): void;
-  execute(_key: string, _req: EnhancedRequest, _handler: () => Promise<Response>): Promise<Response>;
-}
-/**
- * Middleware factory for common use cases
- */
-export declare class MiddlewareFactory {
-  private pipeline: MiddlewarePipeline;
-  constructor(pipeline: MiddlewarePipeline);
-  createAuthMiddleware(options?: {
-    skipPaths?: string[]
-    skipMethods?: string[]
-    requireRoles?: string[]
-    jwtSecret?: string
-  }): MiddlewareHandler;
-  createRateLimitMiddleware(options: {
-    maxRequests: number
-    windowMs: number
-    skipPaths?: string[]
-  }): MiddlewareHandler;
-  createLoggingMiddleware(options?: {
-    level?: string
-    skipPaths?: string[]
-    includeBody?: boolean
-  }): MiddlewareHandler;
-  createCorsMiddleware(options?: {
-    origin?: string | string[]
-    methods?: string[]
-    allowedHeaders?: string[]
-    credentials?: boolean
-  }): MiddlewareHandler;
-}

package/dist/router/middleware.d.ts

@@ -1,5 +0,0 @@
-import type { Router } from './router';
-/**
- * Middleware handling extension for Router class
- */
-export declare function registerMiddlewareHandling(RouterClass: typeof Router): void;

package/dist/router/model-binding.d.ts

@@ -1,7 +0,0 @@
-import {  } from '../model-binding/model-registry';
-import type {  } from '../types';
-import type { Router } from './router';
-/**
- * Model binding extension for Router class
- */
-export declare function registerModelBinding(RouterClass: typeof Router): void;

package/dist/router/optimized-route-matching.d.ts

@@ -1,6 +0,0 @@
-import type { Router } from './router';
-/**
- * Optimized route matching extension for Router class
- * Replaces the original route matching with high-performance trie-based matching
- */
-export declare function registerOptimizedRouteMatching(RouterClass: typeof Router): void;