@weavecode/weave 0.1.1 → 0.1.3

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/reg-exp-router/router.js

@@ -0,0 +1,101 @@
+import { checkOptionalParameter } from "../../utils/url.js";
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
+import { createNullObject } from "../utils.js";
+import { emptyParam, match } from "./matcher.js";
+import { LABEL_REG_EXP_STR, PATH_ERROR, TAIL_WILDCARD_REG_EXP_STR } from "./node.js";
+import { Trie } from "./trie.js";
+//#region src/router/reg-exp-router/router.ts
+let wildcardRegExpCache = createNullObject();
+function buildWildcardRegExp(path) {
+	return wildcardRegExpCache[path] ??= new RegExp(`^${path.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match, metaChar) => metaChar ? `\\${metaChar}` : match === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
+}
+function findMiddleware(middleware, path) {
+	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path)) return [...middleware[k]];
+}
+var RegExpRouter = class {
+	name = "RegExpRouter";
+	#middleware;
+	#routes;
+	#tries;
+	constructor() {
+		this.#middleware = { ["ALL"]: createNullObject() };
+		this.#routes = { ["ALL"]: createNullObject() };
+		this.#tries = { ["ALL"]: new Trie() };
+	}
+	#insertPath(method, path) {
+		try {
+			this.#tries[method].insert(path, !/\*|\/:/.test(path));
+		} catch (e) {
+			throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+		}
+	}
+	add(method, path, handler) {
+		const middleware = this.#middleware;
+		const routes = this.#routes;
+		if (!middleware) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		if (!middleware[method]) {
+			this.#tries[method] = new Trie();
+			for (const handlerMap of [middleware, routes]) {
+				handlerMap[method] = createNullObject();
+				for (const p in handlerMap["ALL"]) {
+					handlerMap[method][p] = [...handlerMap["ALL"][p]];
+					this.#insertPath(method, p);
+				}
+			}
+		}
+		if (path === "/*") path = "*";
+		const methods = method === "ALL" ? Object.keys(middleware) : [method];
+		if (/\*$/.test(path)) {
+			const re = buildWildcardRegExp(path);
+			for (const m of methods) if (!middleware[m][path]) {
+				this.#insertPath(m, path);
+				middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			for (const handlerMap of [middleware, routes]) for (const m of methods) for (const p in handlerMap[m]) re.test(p) && handlerMap[m][p].push([handler, path]);
+			return;
+		}
+		const paths = checkOptionalParameter(path) || [path];
+		for (const path of paths) for (const m of methods) {
+			if (!routes[m][path]) {
+				this.#insertPath(m, path);
+				routes[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			routes[m][path].push([handler, path]);
+		}
+	}
+	match = match;
+	buildAllMatchers() {
+		const matchers = createNullObject();
+		for (const method of Object.keys(this.#routes)) matchers[method] = this.#buildMatcher(method);
+		this.#middleware = this.#routes = this.#tries = void 0;
+		wildcardRegExpCache = createNullObject();
+		return matchers;
+	}
+	#buildMatcher(method) {
+		const middleware = this.#middleware[method];
+		const routes = this.#routes[method];
+		const trie = this.#tries[method];
+		const staticMap = createNullObject();
+		const handlerData = [];
+		const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+		for (const r of [middleware, routes]) for (const path in r) {
+			const handlers = r[path];
+			const pathData = trie.paths[path];
+			if (!pathData) {
+				staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+				continue;
+			}
+			handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [h, trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+				map[key] = paramReplacementMap[pathData[1][i][1]];
+				return map;
+			}, createNullObject())]);
+		}
+		return [
+			regexp,
+			indexReplacementMap.map((i) => handlerData[i]),
+			staticMap
+		];
+	}
+};
+//#endregion
+export { RegExpRouter };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/reg-exp-router/trie.js

@@ -0,0 +1,73 @@
+import { createNullObject } from "../utils.js";
+import { Node } from "./node.js";
+//#region src/router/reg-exp-router/trie.ts
+var Trie = class {
+	#context = { varIndex: 0 };
+	#root = new Node();
+	#index = 0;
+	paths = createNullObject();
+	insert(path, isStatic) {
+		if (isStatic) {
+			this.#root.insert(path.split(""), 0, [], this.#context, true);
+			return;
+		}
+		const paramAssoc = [];
+		const groups = [];
+		let markedPath = path;
+		for (let i = 0;;) {
+			let replaced = false;
+			markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+				const mark = `@\\${i}`;
+				groups[i] = [mark, m];
+				i++;
+				replaced = true;
+				return mark;
+			});
+			if (!replaced) break;
+		}
+		/**
+		*  - pattern (:label, :label{0-9]+}, ...)
+		*  - /* wildcard
+		*  - character
+		*/
+		const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+		for (let i = groups.length - 1; i >= 0; i--) {
+			const [mark] = groups[i];
+			for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
+				tokens[j] = tokens[j].replace(mark, groups[i][1]);
+				break;
+			}
+		}
+		this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+		this.paths[path] = [this.#index++, paramAssoc];
+	}
+	buildRegExp() {
+		let regexp = this.#root.buildRegExpStr();
+		if (regexp === "") return [
+			/^$/,
+			[],
+			[]
+		];
+		let captureIndex = 0;
+		const indexReplacementMap = [];
+		const paramReplacementMap = [];
+		regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+			if (handlerIndex !== void 0) {
+				indexReplacementMap[++captureIndex] = Number(handlerIndex);
+				return "$()";
+			}
+			if (paramIndex !== void 0) {
+				paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+				return "";
+			}
+			return "";
+		});
+		return [
+			new RegExp(`^${regexp}`),
+			indexReplacementMap,
+			paramReplacementMap
+		];
+	}
+};
+//#endregion
+export { Trie };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/smart-router/index.js

@@ -0,0 +1,2 @@
+import { SmartRouter } from "./router.js";
+export { SmartRouter };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/smart-router/router.js

@@ -0,0 +1,49 @@
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
+//#region src/router/smart-router/router.ts
+var SmartRouter = class {
+	name = "SmartRouter";
+	#routers = [];
+	#routes = [];
+	constructor(init) {
+		this.#routers = init.routers;
+	}
+	add(method, path, handler) {
+		if (!this.#routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		this.#routes.push([
+			method,
+			path,
+			handler
+		]);
+	}
+	match(method, path) {
+		if (!this.#routes) throw new Error("Fatal error");
+		const routers = this.#routers;
+		const routes = this.#routes;
+		const len = routers.length;
+		let i = 0;
+		let res;
+		for (; i < len; i++) {
+			const router = routers[i];
+			try {
+				for (let i = 0, len = routes.length; i < len; i++) router.add(...routes[i]);
+				res = router.match(method, path);
+			} catch (e) {
+				if (e instanceof UnsupportedPathError) continue;
+				throw e;
+			}
+			this.match = router.match.bind(router);
+			this.#routers = [router];
+			this.#routes = void 0;
+			break;
+		}
+		if (i === len) throw new Error("Fatal error");
+		this.name = `SmartRouter + ${this.activeRouter.name}`;
+		return res;
+	}
+	get activeRouter() {
+		if (this.#routes || this.#routers.length !== 1) throw new Error("No active router has been determined yet.");
+		return this.#routers[0];
+	}
+};
+//#endregion
+export { SmartRouter };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/trie-router/index.js

@@ -0,0 +1,2 @@
+import { TrieRouter } from "./router.js";
+export { TrieRouter };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/trie-router/node.js

@@ -0,0 +1,134 @@
+import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
+import "../../router.js";
+import { createNullObject } from "../utils.js";
+//#region src/router/trie-router/node.ts
+const emptyParams = createNullObject();
+let order = 0;
+var Node = class Node {
+	#methods = [];
+	#children = createNullObject();
+	#patterns = [];
+	#pattern;
+	#params = emptyParams;
+	insert(method, path, handler) {
+		let curNode = this;
+		const parts = splitRoutingPath(path);
+		const possibleKeys = /* @__PURE__ */ new Set();
+		let i = 0;
+		for (const p of parts) {
+			const nextP = parts[++i];
+			const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+			const isParam = Array.isArray(pattern);
+			const key = isParam ? pattern[0] : pattern || p;
+			const child = curNode.#children[key] ||= new Node();
+			if (pattern && !child.#pattern) {
+				child.#pattern = pattern;
+				curNode.#patterns.push(child);
+			}
+			curNode = child;
+			if (isParam) possibleKeys.add(pattern[1]);
+		}
+		curNode.#methods.push({ [method]: {
+			handler,
+			possibleKeys: [...possibleKeys],
+			score: ++order
+		} });
+	}
+	#pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+		for (let i = 0, len = node.#methods.length; i < len; i++) {
+			const m = node.#methods[i];
+			const handlerSet = m[method] || m["ALL"];
+			if (handlerSet) {
+				handlerSet.params = createNullObject();
+				handlerSets.push(handlerSet);
+				for (let i = 0, len = handlerSet.possibleKeys.length; i < len; i++) {
+					const key = handlerSet.possibleKeys[i];
+					handlerSet.params[key] = params?.[key] && !i ? params[key] : nodeParams[key] ?? params?.[key];
+				}
+			}
+		}
+	}
+	search(method, path) {
+		const handlerSets = [];
+		this.#params = emptyParams;
+		let curNodes = [this];
+		const parts = splitPath(path);
+		const curNodesQueue = [];
+		const len = parts.length;
+		let partOffsets = null;
+		for (let i = 0; i < len; i++) {
+			const part = parts[i];
+			const isLast = i === len - 1;
+			const tempNodes = [];
+			for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+				const node = curNodes[j];
+				const nextNode = node.#children[part];
+				if (nextNode) {
+					nextNode.#params = node.#params;
+					if (isLast) {
+						if (nextNode.#children["*"]) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+						this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+					} else tempNodes.push(nextNode);
+				}
+				for (const child of node.#patterns) {
+					const pattern = child.#pattern;
+					const params = node.#params === emptyParams ? {} : { ...node.#params };
+					if (typeof pattern === "string") {
+						if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+							this.#pushHandlerSets(handlerSets, child, method, node.#params);
+							if (pattern === "*") {
+								child.#params = params;
+								tempNodes.push(child);
+							}
+						}
+						continue;
+					}
+					const [, name, matcher] = pattern;
+					if (!part && matcher === true) continue;
+					if (matcher !== true) {
+						if (!partOffsets) {
+							partOffsets = [];
+							let offset = path[0] === "/" ? 1 : 0;
+							for (let p = 0; p < len; p++) {
+								partOffsets[p] = offset;
+								offset += parts[p].length + 1;
+							}
+						}
+						const restPathString = path.slice(partOffsets[i]);
+						const m = matcher.exec(restPathString);
+						if (m) {
+							params[name] = m[0];
+							this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+							if (m[0].length === restPathString.length && child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+							for (const _ in child.#children) {
+								child.#params = params;
+								const componentCount = m[0].match(/\//g)?.length ?? 0;
+								(curNodesQueue[componentCount] ||= []).push(child);
+								break;
+							}
+							continue;
+						}
+					}
+					if (matcher === true || matcher.test(part)) {
+						params[name] = part;
+						if (isLast) {
+							this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+							if (child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+						} else {
+							child.#params = params;
+							tempNodes.push(child);
+						}
+					}
+				}
+			}
+			const shifted = curNodesQueue.shift();
+			curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+		}
+		if (handlerSets[1]) handlerSets.sort((a, b) => {
+			return a.score - b.score;
+		});
+		return [handlerSets.map(({ handler, params }) => [handler, params])];
+	}
+};
+//#endregion
+export { Node };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/trie-router/router.js

@@ -0,0 +1,15 @@
+import { checkOptionalParameter } from "../../utils/url.js";
+import { Node } from "./node.js";
+//#region src/router/trie-router/router.ts
+var TrieRouter = class {
+	name = "TrieRouter";
+	#node = new Node();
+	add(method, path, handler) {
+		for (const result of checkOptionalParameter(path) || [path]) this.#node.insert(method, result, handler);
+	}
+	match(method, path) {
+		return this.#node.search(method, path);
+	}
+};
+//#endregion
+export { TrieRouter };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router/utils.js

@@ -0,0 +1,4 @@
+//#region src/router/utils.ts
+const createNullObject = () => Object.create(null);
+//#endregion
+export { createNullObject };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/router.js

@@ -0,0 +1,35 @@
+//#region src/router.ts
+/**
+* @module
+* This module provides types definitions and variables for the routers.
+*/
+/**
+* Constant representing all HTTP methods in uppercase.
+*/
+const METHOD_NAME_ALL = "ALL";
+/**
+* Constant representing all HTTP methods in lowercase.
+*/
+const METHOD_NAME_ALL_LOWERCASE = "all";
+/**
+* Array of supported HTTP methods.
+*/
+const METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"options",
+	"patch",
+	"query"
+];
+/**
+* Error message indicating that a route cannot be added because the matcher is already built.
+*/
+const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+/**
+* Error class representing an unsupported path error.
+*/
+var UnsupportedPathError = class extends Error {};
+//#endregion
+export { MESSAGE_MATCHER_IS_ALREADY_BUILT, METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, UnsupportedPathError };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/types/adapter/aws-lambda/conninfo.d.ts

@@ -0,0 +1,30 @@
+import { GetConnInfo } from "../../helper/conninfo/types.js";
+//#region src/adapter/aws-lambda/conninfo.d.ts
+/**
+ * Get connection information from AWS Lambda
+ *
+ * Extracts client IP from various Lambda event sources:
+ * - API Gateway v1 (REST API): requestContext.identity.sourceIp
+ * - API Gateway v2 (HTTP API/Function URLs): requestContext.http.sourceIp
+ * - ALB: Falls back to x-forwarded-for header
+ *
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { handle, getConnInfo } from 'hono/aws-lambda'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const handler = handle(app)
+ * ```
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const getConnInfo: GetConnInfo;
+//#endregion

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/types/adapter/aws-lambda/handler.d.ts

@@ -0,0 +1,230 @@
+import { Env, Schema } from "../../types.js";
+import { Hono } from "../../hono.js";
+import { ALBRequestContext, ApiGatewayRequestContext, ApiGatewayRequestContextV2, Handler, LambdaContext, LatticeRequestContextV2 } from "./types.js";
+//#region src/adapter/aws-lambda/handler.d.ts
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent | LatticeProxyEventV2;
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export interface LatticeProxyEventV2 {
+  version: string;
+  path: string;
+  method: string;
+  headers: Record<string, string[] | undefined>;
+  queryStringParameters: Record<string, string[] | undefined>;
+  body: string | null;
+  isBase64Encoded: boolean;
+  requestContext: LatticeRequestContextV2;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export interface APIGatewayProxyEventV2 {
+  version: string;
+  routeKey: string;
+  headers: Record<string, string | undefined>;
+  multiValueHeaders?: undefined;
+  cookies?: string[];
+  rawPath: string;
+  rawQueryString: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  requestContext: ApiGatewayRequestContextV2;
+  queryStringParameters?: {
+    [name: string]: string | undefined;
+  };
+  pathParameters?: {
+    [name: string]: string | undefined;
+  };
+  stageVariables?: {
+    [name: string]: string | undefined;
+  };
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export interface APIGatewayProxyEvent {
+  version: string;
+  httpMethod: string;
+  headers: Record<string, string | undefined>;
+  multiValueHeaders?: {
+    [headerKey: string]: string[];
+  };
+  path: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  queryStringParameters?: Record<string, string | undefined>;
+  requestContext: ApiGatewayRequestContext;
+  resource: string;
+  multiValueQueryStringParameters?: {
+    [parameterKey: string]: string[];
+  };
+  pathParameters?: Record<string, string>;
+  stageVariables?: Record<string, string>;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export interface ALBProxyEvent {
+  httpMethod: string;
+  headers?: Record<string, string | undefined>;
+  multiValueHeaders?: Record<string, string[] | undefined>;
+  path: string;
+  body: string | null;
+  isBase64Encoded: boolean;
+  queryStringParameters?: Record<string, string | undefined>;
+  multiValueQueryStringParameters?: {
+    [parameterKey: string]: string[];
+  };
+  requestContext: ALBRequestContext;
+}
+type WithHeaders = {
+  headers: Record<string, string | string[]>;
+  multiValueHeaders?: undefined;
+};
+type WithMultiValueHeaders = {
+  headers?: undefined;
+  multiValueHeaders: Record<string, string[]>;
+};
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export type APIGatewayProxyResult = {
+  statusCode: number;
+  statusDescription?: string;
+  body: string;
+  cookies?: string[];
+  isBase64Encoded: boolean;
+} & (WithHeaders | WithMultiValueHeaders);
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => Handler;
+type HandleOptions = {
+  isContentTypeBinary: ((contentType: string) => boolean) | undefined;
+};
+/**
+ * Converts a Hono application to an AWS Lambda handler.
+ *
+ * Accepts events from API Gateway (v1 and v2), Application Load Balancer (ALB),
+ * and Lambda Function URLs.
+ *
+ * @param app - The Hono application instance
+ * @param options - Optional configuration
+ * @param options.isContentTypeBinary - A function to determine if the content type is binary.
+ *                                      If not provided, the default function will be used.
+ * @returns Lambda handler function
+ *
+ * @example
+ * ```js
+ * import { Hono } from 'hono'
+ * import { handle } from 'hono/aws-lambda'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hello from Lambda'))
+ * app.get('/json', (c) => c.json({ message: 'Hello JSON' }))
+ *
+ * export const handler = handle(app)
+ * ```
+ *
+ * @example
+ * ```js
+ * // With custom binary content type detection
+ * import { handle, defaultIsContentTypeBinary } from 'hono/aws-lambda'
+ * export const handler = handle(app, {
+ *   isContentTypeBinary: (contentType) => {
+ *     if (defaultIsContentTypeBinary(contentType)) {
+ *       // default logic same as prior to v4.8.4
+ *       return true
+ *     }
+ *     return contentType.startsWith('image/') || contentType === 'application/pdf'
+ *   }
+ * })
+ * ```
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, { isContentTypeBinary }?: HandleOptions) => (<L extends LambdaEvent>(event: L, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult & (L extends {
+  multiValueHeaders: Record<string, string[]>;
+} ? WithMultiValueHeaders : WithHeaders)>);
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare abstract class EventProcessor<E extends LambdaEvent> {
+  protected abstract getPath(event: E): string;
+  protected abstract getMethod(event: E): string;
+  protected abstract getQueryString(event: E): string;
+  protected abstract getHeaders(event: E): Headers;
+  protected abstract getCookies(event: E, headers: Headers): void;
+  protected abstract setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+  protected getHeaderValue(headers: E['headers'], key: string): string | undefined;
+  protected getDomainName(event: E): string | undefined;
+  createRequest(event: E): Request;
+  createResult(event: E, res: Response, options: Pick<HandleOptions, 'isContentTypeBinary'>): Promise<APIGatewayProxyResult>;
+  setCookies(_event: E, res: Response, result: APIGatewayProxyResult): void;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare class EventV2Processor extends EventProcessor<APIGatewayProxyEventV2> {
+  protected getPath(event: APIGatewayProxyEventV2): string;
+  protected getMethod(event: APIGatewayProxyEventV2): string;
+  protected getQueryString(event: APIGatewayProxyEventV2): string;
+  protected getCookies(event: APIGatewayProxyEventV2, headers: Headers): void;
+  protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+  protected getHeaders(event: APIGatewayProxyEventV2): Headers;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare class EventV1Processor extends EventProcessor<APIGatewayProxyEvent> {
+  protected getPath(event: APIGatewayProxyEvent): string;
+  protected getMethod(event: APIGatewayProxyEvent): string;
+  protected getQueryString(event: APIGatewayProxyEvent): string;
+  protected getCookies(_event: APIGatewayProxyEvent, _headers: Headers): void;
+  protected getHeaders(event: APIGatewayProxyEvent): Headers;
+  protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare class ALBProcessor extends EventProcessor<ALBProxyEvent> {
+  protected getHeaders(event: ALBProxyEvent): Headers;
+  protected getPath(event: ALBProxyEvent): string;
+  protected getMethod(event: ALBProxyEvent): string;
+  protected getQueryString(event: ALBProxyEvent): string;
+  protected getCookies(event: ALBProxyEvent, headers: Headers): void;
+  protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare class LatticeV2Processor extends EventProcessor<LatticeProxyEventV2> {
+  protected getPath(event: LatticeProxyEventV2): string;
+  protected getMethod(event: LatticeProxyEventV2): string;
+  protected getQueryString(): string;
+  protected getHeaders(event: LatticeProxyEventV2): Headers;
+  protected getCookies(): void;
+  protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>;
+/**
+ * Check if the given content type is binary.
+ * This is a default function and may be overwritten by the user via `isContentTypeBinary` option in handler().
+ * @param contentType The content type to check.
+ * @returns True if the content type is binary, false otherwise.
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const defaultIsContentTypeBinary: (contentType: string) => boolean;
+/**
+ * @deprecated `hono/aws-lambda` will be removed in v5. Install `@hono/aws-lambda` and import from there instead.
+ */
+export declare const isContentEncodingBinary: (contentEncoding: string | null) => boolean;
+//#endregion
+export {};