@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/etag/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module
+ * ETag Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+type ETagOptions = {
+    retainedHeaders?: string[];
+    weak?: boolean;
+    generateDigest?: (body: Uint8Array<ArrayBuffer>) => ArrayBuffer | Promise<ArrayBuffer>;
+};
+/**
+ * Default headers to pass through on 304 responses. From the spec:
+ * > The response must not contain a body and must include the headers that
+ * > would have been sent in an equivalent 200 OK response: Cache-Control,
+ * > Content-Location, Date, ETag, Expires, and Vary.
+ */
+export declare const RETAINED_304_HEADERS: string[];
+/**
+ * ETag Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/etag}
+ *
+ * @param {ETagOptions} [options] - The options for the ETag middleware.
+ * @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
+ * @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
+ * @param {function(Uint8Array): ArrayBuffer | Promise<ArrayBuffer>} [options.generateDigest] -
+ * A custom digest generation function. By default, it uses 'SHA-1'
+ * This function is called with the response body as a `Uint8Array` and should return a hash as an `ArrayBuffer` or a Promise of one.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use('/etag/*', etag())
+ * app.get('/etag/abc', (c) => {
+ *   return c.text('Hono is hot')
+ * })
+ * ```
+ */
+export declare const etag: (options?: ETagOptions) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/ip-restriction/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * IP Restriction Middleware for Hono
+ * @module
+ */
+import type { Context, MiddlewareHandler } from '../..';
+import type { AddressType, GetConnInfo } from '../../helper/conninfo';
+/**
+ * Function to get IP Address
+ */
+type GetIPAddr = GetConnInfo | ((c: Context) => string);
+export type IPRestrictionRule = string | ((addr: {
+    addr: string;
+    type: AddressType;
+}) => boolean);
+/**
+ * Rules for IP Restriction Middleware
+ */
+export interface IPRestrictionRules {
+    denyList?: IPRestrictionRule[];
+    allowList?: IPRestrictionRule[];
+}
+/**
+ * IP Restriction Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/ip-restriction}
+ *
+ * @param {GetConnInfo | ((c: Context) => string)} getIP - A function to retrieve the client IP address. Use `getConnInfo` from the appropriate runtime adapter.
+ * @param {IPRestrictionRules} rules - An object with optional `denyList` and `allowList` arrays of IP rules. Each rule can be a static IP, a CIDR range, or a custom function.
+ * @param {(remote: { addr: string; type: AddressType }, c: Context) => Response | Promise<Response>} [onError] - Optional custom handler invoked when a request is blocked. Defaults to returning a 403 Forbidden response.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { ipRestriction } from 'hono/ip-restriction'
+ * import { getConnInfo } from 'hono/cloudflare-workers'
+ *
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '*',
+ *   ipRestriction(getConnInfo, {
+ *     // Block a specific IP and an entire subnet
+ *     denyList: ['192.168.0.5', '10.0.0.0/8'],
+ *     // Only allow requests from localhost and a private range
+ *     allowList: ['127.0.0.1', '::1', '192.168.1.0/24'],
+ *   })
+ * )
+ *
+ * // With a custom error handler
+ * app.use(
+ *   '/admin/*',
+ *   ipRestriction(
+ *     getConnInfo,
+ *     { allowList: ['203.0.113.0/24'] },
+ *     (remote, c) => c.text(`Access denied for ${remote.addr}`, 403)
+ *   )
+ * )
+ *
+ * app.get('/', (c) => c.text('Hello!'))
+ * ```
+ */
+export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: (remote: {
+    addr: string;
+    type: AddressType;
+}, c: Context) => Response | Promise<Response>) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/jsx-renderer/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @module
+ * JSX Renderer Middleware for Hono.
+ */
+import type { Context, PropsForRenderer } from '../../context';
+import type { FC, Context as JSXContext, PropsWithChildren } from '../../jsx';
+import type { Env, Input, MiddlewareHandler } from '../../types';
+export declare const RequestContext: JSXContext<Context<any, any, {}> | null>;
+type RendererOptions = {
+    docType?: boolean | string;
+    stream?: boolean | Record<string, string>;
+};
+type ComponentResult = Exclude<ReturnType<FC>, null>;
+type ComponentWithChildren = (props: PropsWithChildren<PropsForRenderer & {
+    Layout: FC;
+}>, c: Context) => ComponentResult;
+/**
+ * JSX Renderer Middleware for hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/jsx-renderer}
+ *
+ * @param {ComponentWithChildren} [component] - The component to render, which can accept children and props.
+ * @param {RendererOptions} [options] - The options for the JSX renderer middleware.
+ * @param {boolean | string} [options.docType=true] - The DOCTYPE to be added at the beginning of the HTML. If set to false, no DOCTYPE will be added.
+ * @param {boolean | Record<string, string>} [options.stream=false] - If set to true, enables streaming response with default headers. If a record is provided, custom headers will be used.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.get(
+ *   '/page/*',
+ *   jsxRenderer(({ children }) => {
+ *     return (
+ *       <html>
+ *         <body>
+ *           <header>Menu</header>
+ *           <div>{children}</div>
+ *         </body>
+ *       </html>
+ *     )
+ *   })
+ * )
+ *
+ * app.get('/page/about', (c) => {
+ *   return c.render(<h1>About me!</h1>)
+ * })
+ * ```
+ */
+export declare const jsxRenderer: <E extends Env = Env>(component?: ComponentWithChildren, options?: RendererOptions | ((c: Context<E>) => RendererOptions)) => MiddlewareHandler;
+/**
+ * useRequestContext for Hono.
+ *
+ * @template E - The environment type.
+ * @template P - The parameter type.
+ * @template I - The input type.
+ * @returns {Context<E, P, I>} An instance of Context.
+ *
+ * @example
+ * ```ts
+ * const RequestUrlBadge: FC = () => {
+ *   const c = useRequestContext()
+ *   return <b>{c.req.url}</b>
+ * }
+ *
+ * app.get('/page/info', (c) => {
+ *   return c.render(
+ *     <div>
+ *       You are accessing: <RequestUrlBadge />
+ *     </div>
+ *   )
+ * })
+ * ```
+ */
+export declare const useRequestContext: <E extends Env = any, P extends string = any, I extends Input = {}>() => Context<E, P, I>;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/jwk/index.d.ts

@@ -0,0 +1 @@
+export { jwk } from './jwk';

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/jwk/jwk.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @module
+ * JWK Auth Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+import type { CookiePrefixOptions } from '../../utils/cookie';
+import '../../context';
+import type { AsymmetricAlgorithm } from '../../utils/jwt/jwa';
+import type { HonoJsonWebKey } from '../../utils/jwt/jws';
+import type { VerifyOptions } from '../../utils/jwt/jwt';
+/**
+ * JWK Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/jwk}
+ *
+ * @param {object} options - The options for the JWK middleware.
+ * @param {HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[])} [options.keys] - The public keys used for JWK verification, or a function that returns them.
+ * @param {string | ((ctx: Context) => Promise<string> | string)} [options.jwks_uri] - If set to a URI string or a function that returns a URI string, attempt to fetch JWKs from it. The response must be a JSON object containing a `keys` array, which will be merged with the `keys` option.
+ * @param {boolean} [options.allow_anon] - If set to `true`, the middleware allows requests without a token to proceed without authentication.
+ * @param {string} [options.cookie] - If set, the middleware attempts to retrieve the token from a cookie with these options (optionally signed) only if no token is found in the header.
+ * @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
+ * @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
+ * @param {AsymmetricAlgorithm[]} options.alg - An array of allowed asymmetric algorithms for JWT verification. Only tokens signed with these algorithms will be accepted.
+ * @param {RequestInit} [init] - Optional init options for the `fetch` request when retrieving JWKS from a URI.
+ * @param {VerifyOptions} [options.verification] - Additional options for JWK payload verification.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use("/auth/*", jwk({
+ *   jwks_uri: (c) => `https://${c.env.authServer}/.well-known/jwks.json`,
+ *   headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
+ * }))
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
+export declare const jwk: (options: {
+    keys?: HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[]);
+    jwks_uri?: string | ((ctx: Context) => Promise<string> | string);
+    allow_anon?: boolean;
+    cookie?: string | {
+        key: string;
+        secret?: string | BufferSource;
+        prefixOptions?: CookiePrefixOptions;
+    };
+    headerName?: string;
+    alg: AsymmetricAlgorithm[];
+    realm?: string;
+    verification?: VerifyOptions;
+}, init?: RequestInit) => MiddlewareHandler;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/jwt/index.d.ts

@@ -0,0 +1,8 @@
+import type { JwtVariables } from './jwt';
+export type { JwtVariables };
+export { jwt, verifyWithJwks, verify, decode, sign } from './jwt';
+export { AlgorithmTypes } from '../../utils/jwt/jwa';
+declare module '../..' {
+    interface ContextVariableMap extends JwtVariables<unknown> {
+    }
+}

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/jwt/jwt.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @module
+ * JWT Auth Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+import type { CookiePrefixOptions } from '../../utils/cookie';
+import '../../context';
+import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
+import type { SignatureKey } from '../../utils/jwt/jws';
+import type { VerifyOptions } from '../../utils/jwt/jwt';
+export type JwtVariables<T = any> = {
+    jwtPayload: T;
+};
+/**
+ * JWT Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/jwt}
+ *
+ * @param {object} options - The options for the JWT middleware.
+ * @param {SignatureKey} options.secret - A value of your secret key.
+ * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
+ * @param {SignatureAlgorithm} options.alg - An algorithm type that is used for verifying (required). Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
+ * @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
+ * @param {string} [options.realm] - The protection space described by the `realm` parameter of the returned `WWW-Authenticate` challenge header. Defaults to the request URL.
+ * @param {VerifyOptions} [options.verification] - Additional options for JWT payload verification.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   jwt({
+ *     secret: 'it-is-very-secret',
+ *     alg: 'HS256',
+ *     headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
+export declare const jwt: (options: {
+    secret: SignatureKey;
+    cookie?: string | {
+        key: string;
+        secret?: string | BufferSource;
+        prefixOptions?: CookiePrefixOptions;
+    };
+    alg: SignatureAlgorithm;
+    headerName?: string;
+    realm?: string;
+    verification?: VerifyOptions;
+}) => MiddlewareHandler;
+export declare const verifyWithJwks: (token: string, options: {
+    keys?: import("../../utils/jwt/jws").HonoJsonWebKey[];
+    jwks_uri?: string;
+    verification?: VerifyOptions;
+    allowedAlgorithms: readonly import("../../utils/jwt/jwa").AsymmetricAlgorithm[];
+}, init?: RequestInit) => Promise<import("../../utils/jwt/types").JWTPayload>;
+export declare const verify: (token: string, publicKey: SignatureKey, algOrOptions: SignatureAlgorithm | import("../../utils/jwt/jwt").VerifyOptionsWithAlg) => Promise<import("../../utils/jwt/types").JWTPayload>;
+export declare const decode: (token: string) => {
+    header: import("../../utils/jwt/jwt").TokenHeader;
+    payload: import("../../utils/jwt/types").JWTPayload;
+};
+export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/language/index.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageVariables, DetectorOptions, DetectorType, CacheType } from './language';
+export type { LanguageVariables, DetectorOptions, DetectorType, CacheType };
+export { languageDetector, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, } from './language';
+declare module '../..' {
+    interface ContextVariableMap extends LanguageVariables {
+    }
+}

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/language/language.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @module
+ * Language module for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+export type DetectorType = 'path' | 'querystring' | 'cookie' | 'header';
+export type CacheType = 'cookie';
+export interface DetectorOptions {
+    /** Order of language detection strategies */
+    order: DetectorType[];
+    /** Query parameter name for language */
+    lookupQueryString: string;
+    /** Cookie name for language */
+    lookupCookie: string;
+    /** Index in URL path where language code appears */
+    lookupFromPathIndex: number;
+    /** Header key for language detection */
+    lookupFromHeaderKey: string;
+    /** Caching strategies */
+    caches: CacheType[] | false;
+    /** Cookie configuration options */
+    cookieOptions?: {
+        domain?: string;
+        path?: string;
+        sameSite?: 'Strict' | 'Lax' | 'None';
+        secure?: boolean;
+        maxAge?: number;
+        httpOnly?: boolean;
+    };
+    /** Whether to ignore case in language codes */
+    ignoreCase: boolean;
+    /** Default language if none detected */
+    fallbackLanguage: string;
+    /** List of supported language codes */
+    supportedLanguages: string[];
+    /** Optional function to transform detected language codes */
+    convertDetectedLanguage?: (lang: string) => string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+export interface LanguageVariables {
+    language: string;
+}
+export declare const DEFAULT_OPTIONS: DetectorOptions;
+/**
+ * Parse Accept-Language header values with quality scores
+ * @param header Accept-Language header string
+ * @returns Array of parsed languages with quality scores
+ */
+export declare function parseAcceptLanguage(header: string): Array<{
+    lang: string;
+    q: number;
+}>;
+/**
+ * Validate and normalize language codes
+ * @param lang Language code to normalize
+ * @param options Detector options
+ * @returns Normalized language code or undefined
+ */
+export declare const normalizeLanguage: (lang: string | null | undefined, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from query parameter
+ */
+export declare const detectFromQuery: (c: Context, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from cookie
+ */
+export declare const detectFromCookie: (c: Context, options: DetectorOptions) => string | undefined;
+/**
+ * Detects language from Accept-Language header
+ */
+export declare function detectFromHeader(c: Context, options: DetectorOptions): string | undefined;
+/**
+ * Detects language from URL path
+ */
+export declare function detectFromPath(c: Context, options: DetectorOptions): string | undefined;
+/**
+ * Collection of all language detection strategies
+ */
+export declare const detectors: {
+    readonly querystring: (c: Context, options: DetectorOptions) => string | undefined;
+    readonly cookie: (c: Context, options: DetectorOptions) => string | undefined;
+    readonly header: typeof detectFromHeader;
+    readonly path: typeof detectFromPath;
+};
+/** Type for detector functions */
+export type DetectorFunction = (c: Context, options: DetectorOptions) => string | undefined;
+/** Type-safe detector map */
+export type Detectors = Record<keyof typeof detectors, DetectorFunction>;
+/**
+ * Validate detector options
+ * @param options Detector options to validate
+ * @throws Error if options are invalid
+ */
+export declare function validateOptions(options: DetectorOptions): void;
+/**
+ * Language detector middleware factory
+ * @param userOptions Configuration options for the language detector
+ * @returns Hono middleware function
+ *
+ * @example
+ * ```ts
+ * type Variables = LanguageVariables
+ * const app = new Hono<{ Variables: Variables }>()
+ *
+ * app.use(
+ *   languageDetector({
+ *     supportedLanguages: ['en', 'ja'], // Must include fallback
+ *     fallbackLanguage: 'en', // Required
+ *   })
+ * )
+ *
+ * app.get('/', (c) => {
+ *   const lang = c.get('language')
+ *   return c.text(`Current language: ${lang}`)
+ * })
+ * ```
+ */
+export declare const languageDetector: (userOptions: Partial<DetectorOptions>) => MiddlewareHandler;

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/logger/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module
+ * Logger Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+type PrintFunc = (str: string, ...rest: string[]) => void;
+/**
+ * Logger Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/logger}
+ *
+ * @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(logger())
+ * app.get('/', (c) => c.text('Hello Hono!'))
+ * ```
+ */
+export declare const logger: (fn?: PrintFunc) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/method-not-allowed/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @module
+ * Method Not Allowed Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { Hono } from '../../hono';
+import type { Env, MiddlewareHandler } from '../../types';
+type MethodNotAllowedHandler<E extends Env> = (c: Context<E>, allowedMethods: string[]) => Response | Promise<Response>;
+type MethodNotAllowedOptions<E extends Env> = {
+    app: Hono<E, any, any>;
+    onMethodNotAllowed?: MethodNotAllowedHandler<E>;
+};
+/**
+ * Method Not Allowed Middleware for Hono.
+ *
+ * Returns a `405 Method Not Allowed` response with an `Allow` header when the request path
+ * matches a registered route but the request method is not supported.
+ *
+ * @param {MethodNotAllowedOptions} options - The options for the middleware.
+ * @param {Hono} options.app - The Hono instance used by the application.
+ * @param {MethodNotAllowedHandler} [options.onMethodNotAllowed] - Generates the response, including its `Allow` header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(methodNotAllowed({ app }))
+ *
+ * app.get('/hello', (c) => c.text('Hello!'))
+ * app.post('/hello', (c) => c.text('Posted!'))
+ *
+ * // PUT /hello -> 405 Method Not Allowed
+ * // Allow: GET, HEAD, POST
+ * ```
+ *
+ * @example
+ * ```ts
+ * app.use(
+ *   methodNotAllowed({
+ *     app,
+ *     onMethodNotAllowed: (c, methods) =>
+ *       c.json({ error: 'Method Not Allowed' }, 405, { Allow: methods.join(', ') }),
+ *   })
+ * )
+ * ```
+ */
+export declare const methodNotAllowed: <E extends Env = Env>(options: MethodNotAllowedOptions<E>) => MiddlewareHandler<E>;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/method-override/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module
+ * Method Override Middleware for Hono.
+ */
+import type { Hono } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
+type MethodOverrideOptions = {
+    app: Hono<any, any, any>;
+} & ({
+    form?: string;
+    header?: never;
+    query?: never;
+} | {
+    form?: never;
+    header: string;
+    query?: never;
+} | {
+    form?: never;
+    header?: never;
+    query: string;
+});
+/**
+ * Method Override Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/method-override}
+ *
+ * @param {MethodOverrideOptions} options - The options for the method override middleware.
+ * @param {Hono} options.app - The instance of Hono is used in your application.
+ * @param {string} [options.form=_method] - Form key with a value containing the method name.
+ * @param {string} [options.header] - Header name with a value containing the method name.
+ * @param {string} [options.query] - Query parameter key with a value containing the method name.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * // If no options are specified, the value of `_method` in the form,
+ * // e.g. DELETE, is used as the method.
+ * app.use('/posts', methodOverride({ app }))
+ *
+ * app.delete('/posts', (c) => {
+ *   // ....
+ * })
+ * ```
+ */
+export declare const methodOverride: (options: MethodOverrideOptions) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/powered-by/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module
+ * Powered By Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+type PoweredByOptions = {
+    /**
+     * The value for X-Powered-By header.
+     * @default Hono
+     */
+    serverName?: string;
+};
+/**
+ * Powered By Middleware for Hono.
+ *
+ * @param options - The options for the Powered By Middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * import { poweredBy } from 'hono/powered-by'
+ *
+ * const app = new Hono()
+ *
+ * app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
+ * ```
+ */
+export declare const poweredBy: (options?: PoweredByOptions) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/pretty-json/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module
+ * Pretty JSON Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+interface PrettyOptions {
+    /**
+     * Number of spaces for indentation.
+     * @default 2
+     */
+    space?: number;
+    /**
+     * Query conditions for when to Pretty.
+     * @default 'pretty'
+     */
+    query?: string;
+    /**
+     * Force prettification of JSON responses regardless of query parameters.
+     * @default false
+     */
+    force?: boolean;
+}
+/**
+ * Pretty JSON Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/pretty-json}
+ *
+ * @param options - The options for the pretty JSON middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
+ * app.get('/', (c) => {
+ *   return c.json({ message: 'Hono!' })
+ * })
+ * ```
+ */
+export declare const prettyJSON: (options?: PrettyOptions) => MiddlewareHandler;
+export {};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/types/middleware/request-id/index.d.ts

@@ -0,0 +1,7 @@
+import type { RequestIdVariables } from './request-id';
+export type { RequestIdVariables };
+export { requestId } from './request-id';
+declare module '../..' {
+    interface ContextVariableMap extends RequestIdVariables {
+    }
+}