@bleedingdev/modern-js-types 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/cli/index.d.ts

@@ -0,0 +1,151 @@
+import type { Config as JestConfigTypes } from '@jest/types';
+
+export type JestConfig = JestConfigTypes.Config;
+
+export interface TestConfig {
+  /**
+   * Decide which transformer will be used to compile file
+   * @default 'babel-jest'
+   */
+  transformer?: 'babel-jest' | 'ts-jest';
+
+  /**
+   * Original jest config
+   * Doc: https://jestjs.io/docs/configuration
+   */
+  jest?: JestConfig | ((jestConfig: JestConfig) => JestConfig);
+}
+
+/**
+ * Bundle entrypoint
+ */
+export interface Entrypoint {
+  entryName: string;
+  isMainEntry: boolean;
+  entry: string;
+  internalEntry?: string;
+  nestedRoutesEntry?: string;
+  pageRoutesEntry?: string;
+  isAutoMount?: boolean;
+  /**
+   * use src/{entryName}/entry.tsx to custom entry
+   */
+  customEntry?: boolean;
+
+  customServerEntry?: string | false;
+
+  fileSystemRoutes?: {
+    globalApp?: string | false;
+    routes?: any[];
+  };
+  absoluteEntryDir?: string;
+  /**
+   * use source.entries to custom entry
+   */
+  isCustomSourceEntry?: boolean;
+}
+
+/**
+ * file system routes.
+ */
+export type RouteLegacy = {
+  path: string;
+  exact: boolean;
+  component: string;
+  _component: string;
+  routes?: RouteLegacy[];
+  parent?: RouteLegacy;
+};
+
+export interface Route {
+  caseSensitive?: boolean;
+  path?: string;
+  id?: string;
+  loader?: any;
+  action?: any;
+  hasErrorBoundary?: boolean;
+  shouldRevalidate?: any;
+  handle?: any;
+  index?: boolean;
+  children?: Route[] | undefined;
+  element?: React.ReactNode | null;
+  errorElement?: React.ReactNode | null;
+  type: string;
+}
+
+export type NestedRouteForCli = NestedRoute<string>;
+
+export interface NestedRoute<T = string | (() => JSX.Element)> extends Route {
+  type: 'nested';
+  origin: 'file-system' | 'config';
+  // Route type to distinguish between page and layout routes
+  routeType?: 'page' | 'layout';
+  parentId?: string;
+  data?: string;
+  clientData?: string;
+  children?: NestedRoute<T>[];
+  filename?: string;
+  _component?: string;
+  component?: T;
+  lazyImport?: () => Promise<any>;
+  loading?: T;
+  error?: T;
+  isRoot?: boolean;
+  config?: string | Record<string, any>;
+  inValidSSRRoute?: boolean;
+  isClientComponent?: boolean;
+  params?: string[];
+}
+
+export interface PageRoute extends Route {
+  type: 'page';
+  parent?: PageRoute;
+  _component: string;
+  component: string;
+  children?: PageRoute[];
+}
+
+/**
+ * custom html partials.
+ */
+export interface HtmlPartials {
+  top: string[];
+  head: string[];
+  body: string[];
+}
+
+export interface HtmlTemplates {
+  [name: string]: string;
+}
+
+export type SSGRouteOptions =
+  | string
+  | {
+      url: string;
+      output?: string;
+      headers?: Record<string, any>;
+    };
+
+export type SSGSingleEntryOptions =
+  | boolean
+  | {
+      headers?: Record<string, any>;
+      routes?: SSGRouteOptions[];
+    };
+
+export type SSGSingleEntryOptionsFactory = (
+  entryName: string,
+  ctx: { baseUrl?: string | string[] },
+) => SSGSingleEntryOptions;
+
+export type SSGMultiEntryOptions = Record<
+  string,
+  SSGSingleEntryOptions | SSGSingleEntryOptionsFactory
+>;
+
+export type SSGConfig =
+  | boolean
+  | SSGSingleEntryOptions
+  | SSGSingleEntryOptionsFactory;
+
+export type { Merge } from 'type-fest';

package/common/index.d.ts

@@ -0,0 +1,16 @@
+export * from './babel';
+export * from './moduleSdk';
+
+export type InternalPlugins = Record<
+  string,
+  string | { path: string; forced?: boolean }
+>;
+
+export type ServerPlugin = {
+  /** The plugin package.json's name  */
+  name: string;
+
+  options?: Record<string, any>;
+};
+
+export type SSRMode = 'string' | 'stream' | false;

package/common/moduleSdk.d.ts

@@ -0,0 +1,101 @@
+export type ModuleRuntimeLane =
+  | 'effect-first'
+  | 'tanstack-first'
+  | 'hono-compat'
+  | 'react-router-compat';
+
+export type ModuleLifecycleHook =
+  | 'registerRoutes'
+  | 'registerCapabilities'
+  | 'registerMigrations'
+  | 'registerEventContracts';
+
+export type ModulePolicyHook =
+  | 'authorize'
+  | 'enforceTenantScope'
+  | 'validateOperationContext'
+  | 'validateEventEnvelope';
+
+export type ModuleObservabilityHook =
+  | 'emitBusinessMetric'
+  | 'emitAuditEvent'
+  | 'emitTraceContext'
+  | 'emitEventContractViolation';
+
+export type ModuleObservabilitySignal = 'metrics' | 'audit' | 'trace';
+export type ModuleComplianceFlagName =
+  | keyof ModuleComplianceFlags
+  | (string & {});
+export type ModuleLifecycleHookName = ModuleLifecycleHook | (string & {});
+export type ModulePolicyHookName = ModulePolicyHook | (string & {});
+export type ModuleObservabilityHookName =
+  | ModuleObservabilityHook
+  | (string & {});
+export type ModuleObservabilitySignalName =
+  | ModuleObservabilitySignal
+  | (string & {});
+
+export interface ModuleComplianceFlags {
+  usesSdkContracts: boolean;
+  usesPolicyMiddleware: boolean;
+  usesObservabilityHooks: boolean;
+}
+
+export interface ModuleSdkSharedRequirements {
+  requiredManifestFields: string[];
+  requiredComplianceFlags: ModuleComplianceFlagName[];
+  requiredObservabilitySignals: ModuleObservabilitySignalName[];
+  requiredLifecycleHooks: ModuleLifecycleHookName[];
+  requiredPolicyHooks: ModulePolicyHookName[];
+  requiredObservabilityHooks: ModuleObservabilityHookName[];
+  forbiddenCodePatterns: string[];
+}
+
+export interface ModuleSdkProfileContract {
+  requiredManifestFields?: string[];
+  requiredComplianceFlags?: ModuleComplianceFlagName[];
+  requiredObservabilitySignals?: ModuleObservabilitySignalName[];
+  requiredLifecycleHooks?: ModuleLifecycleHookName[];
+  requiredPolicyHooks?: ModulePolicyHookName[];
+  requiredObservabilityHooks?: ModuleObservabilityHookName[];
+  forbiddenCodePatterns?: string[];
+}
+
+export interface ModuleSdkContracts {
+  schemaVersion: number;
+  compatibilityLanes: ModuleRuntimeLane[];
+  sharedRequirements: ModuleSdkSharedRequirements;
+  profiles?: Record<string, ModuleSdkProfileContract>;
+}
+
+export interface ModuleSdkManifest {
+  moduleId: string;
+  profile?: string;
+  version: string;
+  runtime: ModuleRuntimeLane;
+  sourceDir: string;
+  lifecycleHooks: ModuleLifecycleHookName[];
+  policyHooks: ModulePolicyHookName[];
+  observability: {
+    signals: ModuleObservabilitySignalName[];
+    hooks: ModuleObservabilityHookName[];
+  };
+  compliance: ModuleComplianceFlags & Record<string, boolean>;
+}
+
+export interface ModuleEventContract {
+  name: string;
+  version: number;
+  schemaHash: string;
+  producerModuleId: string;
+  description?: string;
+}
+
+export interface ModuleEventEnvelope<Payload = unknown> {
+  name: string;
+  version: number;
+  schemaHash: string;
+  timestamp: number;
+  payload: Payload;
+  meta?: Record<string, unknown>;
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cli';
+export * from './common';
+export * from './server';

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@bleedingdev/modern-js-types",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/toolkit/types"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.d.ts"
+    },
+    "./server": {
+      "types": "./server/index.d.ts",
+      "default": "./server/index.d.ts"
+    },
+    "./cli": {
+      "types": "./cli/index.d.ts",
+      "default": "./cli/index.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./index.d.ts"
+      ],
+      "server": [
+        "./server/index.d.ts"
+      ],
+      "cli": [
+        "./cli/index.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^25.8.0",
+    "http-proxy-middleware": "^4.0.0",
+    "type-fest": "5.6.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "test": "rstest --passWithNoTests"
+  },
+  "main": ""
+}

package/packages/hoist-non-react-statics.d.ts

@@ -0,0 +1,71 @@
+interface REACT_STATICS {
+  childContextTypes: true;
+  contextType: true;
+  contextTypes: true;
+  defaultProps: true;
+  displayName: true;
+  getDefaultProps: true;
+  getDerivedStateFromError: true;
+  getDerivedStateFromProps: true;
+  mixins: true;
+  propTypes: true;
+  type: true;
+}
+
+interface KNOWN_STATICS {
+  name: true;
+  length: true;
+  prototype: true;
+  caller: true;
+  callee: true;
+  arguments: true;
+  arity: true;
+}
+
+interface MEMO_STATICS {
+  $$typeof: true;
+  compare: true;
+  defaultProps: true;
+  displayName: true;
+  propTypes: true;
+  type: true;
+}
+
+interface FORWARD_REF_STATICS {
+  $$typeof: true;
+  render: true;
+  defaultProps: true;
+  displayName: true;
+  propTypes: true;
+}
+declare namespace hoistNonReactStatics {
+  type NonReactStatics<
+    S extends React.ComponentType<any>,
+    C extends {
+      [key: string]: true;
+    } = {},
+  > = {
+    [key in Exclude<
+      keyof S,
+      S extends React.MemoExoticComponent<any>
+        ? keyof MEMO_STATICS | keyof C
+        : S extends React.ForwardRefExoticComponent<any>
+          ? keyof FORWARD_REF_STATICS | keyof C
+          : keyof REACT_STATICS | keyof KNOWN_STATICS | keyof C
+    >]: S[key];
+  };
+}
+declare module 'hoist-non-react-statics' {
+  declare function hoistNonReactStatics<
+    T extends React.ComponentType<any>,
+    S extends React.ComponentType<any>,
+    C extends {
+      [key: string]: true;
+    } = {},
+  >(
+    TargetComponent: T,
+    SourceComponent: S,
+    customStatic?: C,
+  ): T & hoistNonReactStatics.NonReactStatics<S, C>;
+  export default hoistNonReactStatics;
+}

package/rstest.config.mts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  globals: true,
+});

package/server/bff.d.ts

@@ -0,0 +1 @@
+export type HttpMethodDecider = 'functionName' | 'inputParams';

package/server/context.d.ts

@@ -0,0 +1,107 @@
+import type { SSRMode } from 'common';
+import type {
+  Server as HttpServer,
+  IncomingHttpHeaders,
+  IncomingMessage,
+  ServerResponse,
+} from 'http';
+import type qs from 'querystring';
+import type { Logger, Metrics, Reporter, ServerTiming } from './utils';
+
+export interface RequestPayload {
+  [key: string]: unknown;
+}
+
+export interface ModernServerContext {
+  req: IncomingMessage;
+
+  res: ServerResponse & { locals?: Record<string, any> };
+
+  params: Record<string, string>;
+
+  logger: Logger;
+
+  metrics: Metrics;
+
+  reporter: Reporter;
+
+  serverTiming: ServerTiming;
+
+  setParams: (params: Record<string, string>) => void;
+
+  getReqHeader: (key: string) => void;
+
+  headers: IncomingHttpHeaders;
+
+  method: string;
+
+  url: string;
+
+  host: string;
+
+  protocol: string;
+
+  origin: string;
+
+  href: string;
+
+  path: string;
+
+  querystring: string;
+
+  query: qs.ParsedUrlQuery;
+
+  status: number;
+
+  serverData: Record<string, any>;
+
+  resHasHandled: () => boolean;
+
+  error: (dig: string, e: Error | string = '') => void;
+
+  setServerData: (key: string, value: any) => void;
+}
+
+export interface BaseResponseLike {
+  setHeader: (key: string, value: string) => void;
+  status: (code: number) => void;
+  locals: Record<string, any>;
+}
+
+export type BaseSSRServerContext<T extends 'node' | 'worker' = 'node'> = {
+  baseUrl: string;
+  request: {
+    params: Record<string, string>;
+    pathname: string;
+    query: Record<string, string>;
+    headers: IncomingHttpHeaders;
+    host: string;
+    url: string;
+    referer?: string;
+    userAgent?: string;
+    cookie?: string;
+    cookieMap?: Record<string, string>;
+  };
+  response: BaseResponseLike;
+  loadableStats: Record<string, any>;
+  routeManifest?: Record<string, any>;
+  template: string;
+  entryName: string;
+  loaderContext: Map<string, unknown>;
+  logger: Logger;
+  serverTiming: ServerTiming;
+  reporter?: Reporter;
+  cacheConfig?: any;
+
+  enableUnsafeCtx?: boolean;
+
+  unsafeHeaders?: string[];
+
+  nonce?: string;
+  /** SSR type  */
+  mode?: SSRMode;
+};
+
+export interface ServerInitHookContext {
+  app?: HttpServer;
+}

package/server/devServer.d.ts

@@ -0,0 +1,17 @@
+import type { NodeRequest, NodeResponse } from '@modern-js/server-core/node';
+import type { DevProxyOptions, NextFunction } from './utils';
+
+export type DevServerHttpsOptions = boolean | { key: string; cert: string };
+
+export type RequestHandler = (
+  req: NodeRequest,
+  res: NodeResponse,
+  next: NextFunction,
+) => void;
+
+export type ExposeServerApis = {
+  sockWrite: (
+    type: string,
+    data?: string | boolean | Record<string, any>,
+  ) => void;
+};

package/server/hook.d.ts

@@ -0,0 +1,97 @@
+import type {
+  IncomingHttpHeaders,
+  IncomingMessage,
+  ServerResponse,
+} from 'http';
+import type { ServerRoute } from './route';
+import type { NodeRequest, NodeResponse } from './server';
+import type { Logger, Metrics, Reporter } from './utils';
+
+export type CookieAPI = {
+  /**
+   * @deprecated Using set empty cookie instead.
+   */
+  delete?: (key: string) => void;
+  get?: (key: string) => string;
+  set: (key: string, value: string, options?: any) => void;
+  clear: () => void;
+};
+
+export interface ModernResponse {
+  get: (key: string) => string | number | string[] | undefined;
+  set: (key: string, value: string | number) => void;
+  status: (code: number) => void;
+  getStatus: () => number;
+  cookies: CookieAPI;
+  raw: (
+    body: string,
+    options?: { status?: number; headers?: Record<string, any> },
+  ) => void;
+}
+
+export interface ModernRequest {
+  url: string;
+  host: string;
+  pathname: string;
+  query: Record<string, any>;
+  cookie: string;
+  cookies: Pick<CookieAPI, 'get'>;
+  headers: IncomingHttpHeaders;
+}
+
+export type HookContext = {
+  response: ModernResponse;
+  request: ModernRequest;
+  logger: Logger;
+  metrics?: Metrics;
+};
+
+export type AfterMatchContext = HookContext & {
+  router: {
+    readonly current: string;
+    readonly url: string;
+    readonly status: number;
+    redirect: (url: string, status?: number) => void;
+    rewrite: (entry: string) => void;
+    use: (entry: string) => void;
+  };
+};
+
+export type AfterRenderContext = HookContext & {
+  route?: Partial<
+    Pick<
+      ServerRoute,
+      'entryName' | 'bundle' | 'isSPA' | 'isSSR' | 'urlPath' | 'entryPath'
+    >
+  >;
+  template: {
+    set: (content: string) => void;
+    // FIXME: break change
+    // get: () => Promise<string>;
+    get: () => string;
+    prependHead: (fragment: string) => void;
+    appendHead: (fragment: string) => void;
+    prependBody: (fragment: string) => void;
+    appendBody: (fragment: string) => void;
+  };
+};
+
+export type AfterStreamingRenderContext = HookContext & {
+  route?: Partial<
+    Pick<
+      ServerRoute,
+      'entryName' | 'bundle' | 'isSPA' | 'isSSR' | 'urlPath' | 'entryPath'
+    >
+  >;
+  chunk: string;
+};
+
+export type MiddlewareContext<T extends 'worker' | 'node' = 'node'> =
+  HookContext & {
+    reporter?: Reporter;
+    response: ModernResponse & { locals: Record<string, any> };
+    source: {
+      req: T extends 'worker' ? Request : NodeRequest;
+      res: T extends 'worker' ? ModernResponse : NodeResponse;
+    };
+  };

package/server/index.d.ts

@@ -0,0 +1,10 @@
+export * from './bff';
+export * from './context';
+export * from './devServer';
+export * from './hook';
+export * from './middleware';
+export * from './monitor';
+export * from './route';
+export * from './rsc';
+export * from './server';
+export * from './utils';

package/server/monitor.d.ts

@@ -0,0 +1,56 @@
+/** Monitor Events  */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+export interface LogEvent {
+  type: 'log';
+  payload: {
+    level: LogLevel;
+    message: string;
+    args?: any[];
+  };
+}
+
+export interface TimingEvent {
+  type: 'timing';
+  payload: {
+    name: string;
+    dur: number;
+    desc?: string;
+    tags?: Record<string, any>;
+    args?: any[];
+  };
+}
+
+export interface CounterEvent {
+  type: 'counter';
+  payload: {
+    name: string;
+    tags?: Record<string, any>;
+    args?: any[];
+  };
+}
+
+export type MonitorEvent = LogEvent | TimingEvent | CounterEvent;
+
+export type CoreMonitor = (event: MonitorEvent) => void;
+
+export interface Monitors {
+  push(monitor: CoreMonitor): void;
+
+  // 日志事件
+  error(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  debug(message: string, ...args: any[]): void;
+  info(message: string, ...args: any[]): void;
+  trace(message: string, ...args: any[]): void;
+
+  // 打点事件
+  timing(
+    name: string,
+    dur: number,
+    desc?: string,
+    tags?: Record<string, any>,
+    ...args: any[]
+  ): void;
+  counter(name: string, tags?: Record<string, any>, ...args: any[]): void;
+}

package/server/route.d.ts

@@ -0,0 +1,24 @@
+export interface ServerRoute {
+  // modern js web entry name
+  entryName?: string;
+  // the url path for request match
+  urlPath: string;
+  // the default asset to response to route
+  entryPath: string;
+  // if route is spa page
+  isSPA?: boolean;
+  // if route is ssr page
+  isSSR?: boolean;
+  // if route is rsc page
+  isRSC?: boolean;
+  // if route is stream response
+  isStream?: boolean;
+  // if route is api service
+  isApi?: boolean;
+  // worker js bundle for ssr page
+  worker?: string;
+  // ssr js bundle for ssr page
+  bundle?: string;
+  // response header for routes
+  responseHeaders?: Record<string, unknown>;
+}

package/server/rsc.d.ts

@@ -0,0 +1,54 @@
+export type ImportManifestEntry = {
+  id: string | number;
+  chunks: (string | number)[];
+  styles?: string[];
+  name: string;
+};
+
+export interface ClientReference {
+  readonly id: string | number;
+  readonly exportName: string;
+  ssrId?: string | number;
+}
+
+export interface ClientManifest {
+  [id: string]: ImportManifestEntry;
+}
+
+export interface ServerManifest {
+  [id: string]: ImportManifestEntry;
+}
+
+export interface ServerReferencesModuleInfo {
+  readonly exportNames: string[];
+  moduleId?: string | number;
+}
+
+export type ClientReferencesMap = Map<string, ClientReference[]>;
+
+export type ServerReferencesMap = Map<string, ServerReferencesModuleInfo>;
+
+export type ModuleLoading = null | {
+  prefix: string;
+  crossOrigin?: 'use-credentials' | '';
+};
+
+export type SSRModuleMap = {
+  [clientId: string]: {
+    [clientExportName: string]: ImportManifestEntry;
+  };
+};
+
+export type SSRManifest = {
+  moduleMap: SSRModuleMap;
+  moduleLoading: ModuleLoading;
+  styles: string[];
+};
+
+export type ServerManifest = {
+  [id: string]: ImportManifestEntry;
+};
+
+export type ClientManifest = {
+  [id: string]: ImportManifestEntry;
+};

package/server/server.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
+
+export type NodeRequest = IncomingMessage | Http2ServerRequest;
+export type NodeResponse = ServerResponse | Http2ServerResponse;

package/server/utils.d.ts

@@ -0,0 +1,138 @@
+import type { Http2ServerRequest } from 'node:http2';
+import type { IncomingMessage, ServerResponse } from 'http';
+import type {
+  Filter as ProxyFilter,
+  Options as ProxyOptions,
+} from 'http-proxy-middleware';
+import type { NodeRequest } from './server';
+export interface Metrics {
+  emitCounter: (
+    name: string,
+    value: number,
+    prefix?: string,
+    tags?: Record<string, any>,
+  ) => void;
+  emitTimer: (
+    name: string,
+    value: number,
+    prefix?: string,
+    tags?: Record<string, any>,
+  ) => void;
+}
+
+type LoggerFunction = (message: string, ...args: any[]) => void;
+export interface Logger {
+  error: LoggerFunction;
+  info: LoggerFunction;
+  warn: LoggerFunction;
+  debug: LoggerFunction;
+}
+
+export interface ServerTiming {
+  addServeTiming: (name: string, dur: number, decs?: string) => this;
+}
+
+export type Reporter<C = any> = {
+  sessionId?: string;
+  userId?: string;
+  client?: C;
+
+  init: (payload: { entryName: string }) => void | Promise<void>;
+
+  reportError: (
+    content: string,
+    e: Error,
+    extra?: Record<string, string | number>,
+  ) => void;
+
+  reportTiming: (
+    name: string,
+    value: number,
+    extra?: Record<string, string>,
+  ) => void;
+
+  reportInfo: (
+    content: string,
+    extra?: Record<string, string | number>,
+  ) => void;
+
+  reportWarn: (
+    content: string,
+    extra?: Record<string, string | number>,
+  ) => void;
+};
+
+export type NextFunction = () => void;
+
+export type ProxyDetail = ProxyOptions & {
+  bypass?: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    proxyOptions: DevProxyOptions,
+  ) => string | undefined | null | false;
+  context?: ProxyFilter;
+};
+
+export type DevProxyOptions =
+  | Record<string, string>
+  | Record<string, ProxyDetail>
+  | ProxyDetail[]
+  | ProxyDetail;
+
+export type CacheControl = {
+  /**
+   * The maxAge like http cache-control: max-age.
+   *
+   * It refers to the cache validation time, measured in (ms).
+   */
+  maxAge: number;
+
+  /**
+   * The staleWhileRevalidate reference to http header cache-control: stale-while-revalidate.
+   *
+   * It means that the cache is stale but can still be used directly while asynchronously revalidating it, measured in (ms).
+   */
+  staleWhileRevalidate: number;
+
+  /**
+   * Specify a custom cache key yourself.
+   *
+   * The custom key will override the key used by default.
+   */
+  customKey?: string | ((pathname: string) => string);
+};
+
+export type CacheOptionProvider = (
+  req: NodeRequest,
+) => Promise<CacheControl | false> | CacheControl | false;
+
+export type CacheOption =
+  | false
+  | CacheOptionProvider
+  | CacheControl
+  | Record<string, CacheControl | CacheOptionProvider>;
+
+export interface Container<K = string, V = string> {
+  /**
+   * Returns a specified element from the container. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Container.
+   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+   */
+  get: (key: K) => Promise<V | undefined>;
+
+  /**
+   * Adds a new element with a specified key and value to the container. If an element with the same key already exists, the element will be updated.
+   */
+  set: (key: K, value: V, options?: { ttl?: number }) => Promise<this>;
+
+  /**
+   * @returns boolean indicating whether an element with the specified key exists or not.
+   */
+  has: (key: K) => Promise<boolean>;
+
+  /**
+   * @returns true if an element in the container existed and has been removed, or false if the element does not exist.
+   */
+  delete: (key: K) => Promise<boolean>;
+
+  forEach?: (callbackFn: (v: V, k: K, container: this) => void) => void;
+}