import type { LambdaEvent } from './handler'
                import { getProcessor, isContentEncodingBinary, isContentTypeBinary } from './handler'
                
                describe('isContentTypeBinary', () => {
                  it('Should determine whether it is binary', () => {
                    expect(isContentTypeBinary('image/png')).toBe(true)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('font/woff2')).toBe(true)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('image/svg+xml')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('image/svg+xml; charset=UTF-8')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('text/plain')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('text/plain; charset=UTF-8')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('text/css')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('text/javascript')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('application/json')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('application/ld+json')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                    expect(isContentTypeBinary('application/json; charset=UTF-8')).toBe(false)          
(alias) isContentTypeBinary(contentType: string): boolean
import isContentTypeBinary
                  })
                })
                
                describe('isContentEncodingBinary', () => {
                  it('Should determine whether it is compressed', () => {
                    expect(isContentEncodingBinary('gzip')).toBe(true)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('compress')).toBe(true)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('deflate')).toBe(true)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('br')).toBe(true)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('deflate, gzip')).toBe(true)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('')).toBe(false)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                    expect(isContentEncodingBinary('unknown')).toBe(false)          
(alias) isContentEncodingBinary(contentEncoding: string | null): boolean
import isContentEncodingBinary
                  })
                })
                
                describe('EventProcessor.createRequest', () => {
                  it('Should return valid Request object from version 1.0 API Gateway event', () => {
                    const event:
const event: LambdaEvent LambdaEvent = {          
(alias) type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
import LambdaEvent
                      version: '1.0',          
(property) APIGatewayProxyEvent.version: string
                      resource: '/my/path',          
(property) APIGatewayProxyEvent.resource: string
                      path: '/my/path',          
(property) path: string
                      httpMethod: 'GET',          
(property) httpMethod: string
                      headers: {          
(property) headers: {
    'content-type': string;
    header1: string;
    header2: string;
}
                        'content-type': 'application/json',
                        header1: 'value1',          
(property) header1: string
                        header2: 'value1',          
(property) header2: string
                      },
                      multiValueHeaders: {          
(property) multiValueHeaders: {
    header1: string[];
    header2: string[];
}
                        header1: ['value1'],          
(property) header1: string[]
                        header2: ['value1', 'value2', 'value3'],          
(property) header2: string[]
                      },
                      queryStringParameters: {          
(property) queryStringParameters: {
    parameter2: string;
}
                        parameter2: 'value',          
(property) parameter2: string
                      },
                      multiValueQueryStringParameters: {          
(property) multiValueQueryStringParameters: {
    parameter1: string[];
    parameter2: string[];
}
                        parameter1: ['value1', 'value2'],          
(property) parameter1: string[]
                        parameter2: ['value'],          
(property) parameter2: string[]
                      },
                      requestContext: {          
(property) requestContext: {
    accountId: string;
    apiId: string;
    authorizer: {
        claims: null;
        scopes: null;
    };
    domainName: string;
    domainPrefix: string;
    extendedRequestId: string;
    httpMethod: string;
    identity: {
        sourceIp: string;
        userAgent: string;
        clientCert: {
            ...;
        };
    };
    ... 6 more ...;
    stage: string;
}
                        accountId: '123456789012',          
(property) accountId: string
                        apiId: 'id',          
(property) apiId: string
                        authorizer: {          
(property) authorizer: {
    claims: null;
    scopes: null;
}
                          claims: null,          
(property) claims?: unknown
                          scopes: null,          
(property) scopes?: unknown
                        },
                        domainName: 'id.execute-api.us-east-1.amazonaws.com',          
(property) domainName: string
                        domainPrefix: 'id',          
(property) domainPrefix: string
                        extendedRequestId: 'request-id',          
(property) ApiGatewayRequestContext.extendedRequestId: string
                        httpMethod: 'GET',          
(property) ApiGatewayRequestContext.httpMethod: string
                        identity: {          
(property) ApiGatewayRequestContext.identity: Identity
                          sourceIp: '192.0.2.1',          
(property) Identity.sourceIp: string
                          userAgent: 'user-agent',          
(property) Identity.userAgent: string
                          clientCert: {          
(property) Identity.clientCert?: ClientCert | undefined
                            clientCertPem: 'CERT_CONTENT',          
(property) ClientCert.clientCertPem: string
                            subjectDN: 'www.example.com',          
(property) ClientCert.subjectDN: string
                            issuerDN: 'Example issuer',          
(property) ClientCert.issuerDN: string
                            serialNumber: 'a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1',          
(property) ClientCert.serialNumber: string
                            validity: {          
(property) ClientCert.validity: {
    notBefore: string;
    notAfter: string;
}
                              notBefore: 'May 28 12:30:02 2019 GMT',          
(property) notBefore: string
                              notAfter: 'Aug  5 09:36:04 2021 GMT',          
(property) notAfter: string
                            },
                          },
                        },
                        path: '/my/path',          
(property) ApiGatewayRequestContext.path: string
                        protocol: 'HTTP/1.1',          
(property) ApiGatewayRequestContext.protocol: string
                        requestId: 'id=',          
(property) requestId: string
                        requestTime: '04/Mar/2020:19:15:17 +0000',          
(property) ApiGatewayRequestContext.requestTime: string
                        requestTimeEpoch: 1583349317135,          
(property) ApiGatewayRequestContext.requestTimeEpoch: number
                        resourcePath: '/my/path',          
(property) ApiGatewayRequestContext.resourcePath: string
                        stage: '$default',          
(property) stage: string
                      },
                      pathParameters: {},          
(property) APIGatewayProxyEvent.pathParameters?: Record<string, string> | undefined
                      stageVariables: {},          
(property) APIGatewayProxyEvent.stageVariables?: Record<string, string> | undefined
                      body: null,          
(property) body: null
                      isBase64Encoded: false,          
(property) isBase64Encoded: false
                    }
                
                    const processor =
const processor: EventProcessor<LambdaEvent> getProcessor
(alias) getProcessor(event: LambdaEvent): EventProcessor<LambdaEvent>
import getProcessor(event)          
const event: APIGatewayProxyEvent
                    const request =
const request: Request processor
const processor: EventProcessor<LambdaEvent>.createRequest
(method) EventProcessor<LambdaEvent>.createRequest(event: LambdaEvent): Request(event)          
const event: APIGatewayProxyEvent
                
                    expect(request
const request: Request.method).toEqual('GET')          
(property) Request.method: string
Returns request's HTTP method, which is "GET" by default.
MDN Reference
                    expect(request
const request: Request.url).toEqual(          
(property) Request.url: string
Returns the URL of request as a string.
MDN Reference
                      'https://id.execute-api.us-east-1.amazonaws.com/my/path?parameter2=value'
                    )
                    expect(Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..fromEntries
(method) ObjectConstructor.fromEntries<string>(entries: Iterable<readonly [PropertyKey, string]>): {
    [k: string]: string;
} (+1 overload)
Returns an object created by key-value entries for properties and methods
@param entries — An iterable object that contains key-value entries for properties and methods.(request
const request: Request.headers)).toEqual({          
(property) Request.headers: Headers
Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
MDN Reference
                      'content-type': 'application/json',
                      header1: 'value1',          
(property) header1: string
                      header2: 'value1, value2, value3',          
(property) header2: string
                    })
                  })
                
                  it('Should return valid Request object from version 2.0 API Gateway event', () => {
                    const event:
const event: LambdaEvent LambdaEvent = {          
(alias) type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
import LambdaEvent
                      version: '2.0',          
(property) version: string
                      routeKey: '$default',          
(property) APIGatewayProxyEventV2.routeKey: string
                      rawPath: '/my/path',          
(property) APIGatewayProxyEventV2.rawPath: string
                      rawQueryString: 'parameter1=value1¶meter1=value2¶meter2=value',          
(property) APIGatewayProxyEventV2.rawQueryString: string
                      cookies: ['cookie1', 'cookie2'],          
(property) APIGatewayProxyEventV2.cookies?: string[] | undefined
                      headers: {          
(property) headers: {
    'content-type': string;
    header1: string;
    header2: string;
}
                        'content-type': 'application/json',
                        header1: 'value1',          
(property) header1: string
                        header2: 'value1,value2',          
(property) header2: string
                      },
                      queryStringParameters: {          
(property) queryStringParameters: {
    parameter1: string;
    parameter2: string;
}
                        parameter1: 'value1,value2',          
(property) parameter1: string
                        parameter2: 'value',          
(property) parameter2: string
                      },
                      requestContext: {          
(property) requestContext: {
    accountId: string;
    apiId: string;
    authentication: null;
    authorizer: {};
    domainName: string;
    domainPrefix: string;
    http: {
        method: string;
        path: string;
        protocol: string;
        sourceIp: string;
        userAgent: string;
    };
    ... 4 more ...;
    timeEpoch: number;
}
                        accountId: '123456789012',          
(property) accountId: string
                        apiId: 'api-id',          
(property) apiId: string
                        authentication: null,          
(property) ApiGatewayRequestContextV2.authentication: null
                        authorizer: {},          
(property) authorizer: {}
                        domainName: 'id.execute-api.us-east-1.amazonaws.com',          
(property) domainName: string
                        domainPrefix: 'id',          
(property) domainPrefix: string
                        http: {          
(property) ApiGatewayRequestContextV2.http: {
    method: string;
    path: string;
    protocol: string;
    sourceIp: string;
    userAgent: string;
}
                          method: 'POST',          
(property) method: string
                          path: '/my/path',          
(property) path: string
                          protocol: 'HTTP/1.1',          
(property) protocol: string
                          sourceIp: '192.0.2.1',          
(property) sourceIp: string
                          userAgent: 'agent',          
(property) userAgent: string
                        },
                        requestId: 'id',          
(property) requestId: string
                        routeKey: '$default',          
(property) ApiGatewayRequestContextV2.routeKey: string
                        stage: '$default',          
(property) stage: string
                        time: '12/Mar/2020:19:03:58 +0000',          
(property) ApiGatewayRequestContextV2.time: string
                        timeEpoch: 1583348638390,          
(property) ApiGatewayRequestContextV2.timeEpoch: number
                      },
                      body: 'Hello from Lambda',          
(property) body: string
                      pathParameters: {          
(property) pathParameters: {
    parameter1: string;
}
                        parameter1: 'value1',          
(property) parameter1: string
                      },
                      isBase64Encoded: false,          
(property) isBase64Encoded: false
                      stageVariables: {          
(property) stageVariables: {
    stageVariable1: string;
    stageVariable2: string;
}
                        stageVariable1: 'value1',          
(property) stageVariable1: string
                        stageVariable2: 'value2',          
(property) stageVariable2: string
                      },
                    }
                
                    const processor =
const processor: EventProcessor<LambdaEvent> getProcessor
(alias) getProcessor(event: LambdaEvent): EventProcessor<LambdaEvent>
import getProcessor(event)          
const event: APIGatewayProxyEventV2
                    const request =
const request: Request processor
const processor: EventProcessor<LambdaEvent>.createRequest
(method) EventProcessor<LambdaEvent>.createRequest(event: LambdaEvent): Request(event)          
const event: APIGatewayProxyEventV2
                
                    expect(request
const request: Request.method).toEqual('POST')          
(property) Request.method: string
Returns request's HTTP method, which is "GET" by default.
MDN Reference
                    expect(request
const request: Request.url).toEqual(          
(property) Request.url: string
Returns the URL of request as a string.
MDN Reference
                      'https://id.execute-api.us-east-1.amazonaws.com/my/path?parameter1=value1¶meter1=value2¶meter2=value'
                    )
                    expect(Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..fromEntries
(method) ObjectConstructor.fromEntries<string>(entries: Iterable<readonly [PropertyKey, string]>): {
    [k: string]: string;
} (+1 overload)
Returns an object created by key-value entries for properties and methods
@param entries — An iterable object that contains key-value entries for properties and methods.(request
const request: Request.headers)).toEqual({          
(property) Request.headers: Headers
Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
MDN Reference
                      'content-type': 'application/json',
                      cookie: 'cookie1; cookie2',          
(property) cookie: string
                      header1: 'value1',          
(property) header1: string
                      header2: 'value1,value2',          
(property) header2: string
                    })
                  })
                })
            

            
                import crypto from 'node:crypto'
                import type { Hono } from '../../hono'
                import type { Env, Schema } from '../../types'
                import { decodeBase64, encodeBase64 } from '../../utils/encode'
                import type {
                  ALBRequestContext,
                  ApiGatewayRequestContext,
                  ApiGatewayRequestContextV2,
                  Handler,
                  LambdaContext,
                } from './types'
                
                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                // @ts-ignore
                globalThis.crypto ??= crypto          
var crypto: Crypto
MDN Reference
                
                export type LambdaEvent =
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEvent |
interface APIGatewayProxyEvent APIGatewayProxyEventV2 |
interface APIGatewayProxyEventV2 ALBProxyEvent          
interface ALBProxyEvent
                
                // When calling HTTP API or Lambda directly through function urls
                export interface APIGatewayProxyEventV2 {          
interface APIGatewayProxyEventV2
                  version: string          
(property) APIGatewayProxyEventV2.version: string
                  routeKey: string          
(property) APIGatewayProxyEventV2.routeKey: string
                  headers:
(property) APIGatewayProxyEventV2.headers: Record<string, string | undefined> Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  multiValueHeaders?: undefined          
(property) APIGatewayProxyEventV2.multiValueHeaders?: undefined
                  cookies?: string[]          
(property) APIGatewayProxyEventV2.cookies?: string[] | undefined
                  rawPath: string          
(property) APIGatewayProxyEventV2.rawPath: string
                  rawQueryString: string          
(property) APIGatewayProxyEventV2.rawQueryString: string
                  body: string | null          
(property) APIGatewayProxyEventV2.body: string | null
                  isBase64Encoded: boolean          
(property) APIGatewayProxyEventV2.isBase64Encoded: boolean
                  requestContext:
(property) APIGatewayProxyEventV2.requestContext: ApiGatewayRequestContextV2 ApiGatewayRequestContextV2          
(alias) interface ApiGatewayRequestContextV2
import ApiGatewayRequestContextV2
                  queryStringParameters?: {          
(property) APIGatewayProxyEventV2.queryStringParameters?: {
    [name: string]: string | undefined;
} | undefined
                    [name: string]: string | undefined          
(parameter) name: string
                  }
                  pathParameters?: {          
(property) APIGatewayProxyEventV2.pathParameters?: {
    [name: string]: string | undefined;
} | undefined
                    [name: string]: string | undefined          
(parameter) name: string
                  }
                  stageVariables?: {          
(property) APIGatewayProxyEventV2.stageVariables?: {
    [name: string]: string | undefined;
} | undefined
                    [name: string]: string | undefined          
(parameter) name: string
                  }
                }
                
                // When calling Lambda through an API Gateway
                export interface APIGatewayProxyEvent {          
interface APIGatewayProxyEvent
                  version: string          
(property) APIGatewayProxyEvent.version: string
                  httpMethod: string          
(property) APIGatewayProxyEvent.httpMethod: string
                  headers:
(property) APIGatewayProxyEvent.headers: Record<string, string | undefined> Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  multiValueHeaders?: {          
(property) APIGatewayProxyEvent.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                    [headerKey: string]: string[]          
(parameter) headerKey: string
                  }
                  path: string          
(property) APIGatewayProxyEvent.path: string
                  body: string | null          
(property) APIGatewayProxyEvent.body: string | null
                  isBase64Encoded: boolean          
(property) APIGatewayProxyEvent.isBase64Encoded: boolean
                  queryStringParameters?:
(property) APIGatewayProxyEvent.queryStringParameters?: Record<string, string | undefined> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  requestContext:
(property) APIGatewayProxyEvent.requestContext: ApiGatewayRequestContext ApiGatewayRequestContext          
(alias) interface ApiGatewayRequestContext
import ApiGatewayRequestContext
                  resource: string          
(property) APIGatewayProxyEvent.resource: string
                  multiValueQueryStringParameters?: {          
(property) APIGatewayProxyEvent.multiValueQueryStringParameters?: {
    [parameterKey: string]: string[];
} | undefined
                    [parameterKey: string]: string[]          
(parameter) parameterKey: string
                  }
                  pathParameters?:
(property) APIGatewayProxyEvent.pathParameters?: Record<string, string> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  stageVariables?:
(property) APIGatewayProxyEvent.stageVariables?: Record<string, string> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                }
                
                // When calling Lambda through an Application Load Balancer
                export interface ALBProxyEvent {          
interface ALBProxyEvent
                  httpMethod: string          
(property) ALBProxyEvent.httpMethod: string
                  headers?:
(property) ALBProxyEvent.headers?: Record<string, string | undefined> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  multiValueHeaders?:
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  path: string          
(property) ALBProxyEvent.path: string
                  body: string | null          
(property) ALBProxyEvent.body: string | null
                  isBase64Encoded: boolean          
(property) ALBProxyEvent.isBase64Encoded: boolean
                  queryStringParameters?:
(property) ALBProxyEvent.queryStringParameters?: Record<string, string | undefined> | undefined Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  multiValueQueryStringParameters?: {          
(property) ALBProxyEvent.multiValueQueryStringParameters?: {
    [parameterKey: string]: string[];
} | undefined
                    [parameterKey: string]: string[]          
(parameter) parameterKey: string
                  }
                  requestContext:
(property) ALBProxyEvent.requestContext: ALBRequestContext ALBRequestContext          
(alias) interface ALBRequestContext
import ALBRequestContext
                }
                
                export interface APIGatewayProxyResult {          
interface APIGatewayProxyResult
                  statusCode: number          
(property) APIGatewayProxyResult.statusCode: number
                  statusDescription?: string          
(property) APIGatewayProxyResult.statusDescription?: string | undefined
                  body: string          
(property) APIGatewayProxyResult.body: string
                  headers:
(property) APIGatewayProxyResult.headers: Record<string, string> Record          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                  cookies?: string[]          
(property) APIGatewayProxyResult.cookies?: string[] | undefined
                  multiValueHeaders?: {          
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                    [headerKey: string]: string[]          
(parameter) headerKey: string
                  }
                  isBase64Encoded: boolean          
(property) APIGatewayProxyResult.isBase64Encoded: boolean
                }
                
                const getRequestContext = (          
const getRequestContext: (event: LambdaEvent) => ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                  event:
(parameter) event: LambdaEvent LambdaEvent          
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
                ): ApiGatewayRequestContext |
(alias) interface ApiGatewayRequestContext
import ApiGatewayRequestContext ApiGatewayRequestContextV2 |
(alias) interface ApiGatewayRequestContextV2
import ApiGatewayRequestContextV2 ALBRequestContext => {          
(alias) interface ALBRequestContext
import ALBRequestContext
                  return event
(parameter) event: LambdaEvent.requestContext          
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                }
                
                const streamToNodeStream = async (          
const streamToNodeStream: (reader: ReadableStreamDefaultReader<Uint8Array>, writer: NodeJS.WritableStream) => Promise<void>
                  reader:
(parameter) reader: ReadableStreamDefaultReader<Uint8Array> ReadableStreamDefaultReader
interface ReadableStreamDefaultReader<R = any>
MDN Reference<Uint8Array>,          
interface Uint8Array
A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
requested number of bytes could not be allocated an exception is raised.
                  writer:
(parameter) writer: NodeJS.WritableStream NodeJS.WritableStream          
type NodeJS.WritableStream = /*unresolved*/ any
                ): Promise => {          
interface Promise<T>
Represents the completion of an asynchronous operation
                  let readResult = await
let readResult: ReadableStreamReadResult<Uint8Array> reader
(parameter) reader: ReadableStreamDefaultReader<Uint8Array>.read()          
(method) ReadableStreamDefaultReader<Uint8Array>.read(): Promise<ReadableStreamReadResult<Uint8Array>>
MDN Reference
                  while (!readResult
let readResult: ReadableStreamReadResult<Uint8Array>.done) {          
(property) done: boolean
                    writer.write
(parameter) writer: NodeJS.WritableStream(readResult
let readResult: ReadableStreamReadValueResult<Uint8Array>.value)          
(property) ReadableStreamReadValueResult<Uint8Array>.value: Uint8Array
                    readResult = await
let readResult: ReadableStreamReadResult<Uint8Array> reader
(parameter) reader: ReadableStreamDefaultReader<Uint8Array>.read()          
(method) ReadableStreamDefaultReader<Uint8Array>.read(): Promise<ReadableStreamReadResult<Uint8Array>>
MDN Reference
                  }
                  writer.end()          
(parameter) writer: NodeJS.WritableStream
                }
                
                export const streamHandle = <          
const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => Handler
                  E extends
(type parameter) E in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler Env =
(alias) type Env = {
    Bindings?: Bindings;
    Variables?: Variables;
}
import Env Env,          
(alias) type Env = {
    Bindings?: Bindings;
    Variables?: Variables;
}
import Env
                  S extends
(type parameter) S in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler Schema = {},          
(alias) type Schema = {
    [Path: string]: {
        [Method: `$${Lowercase<string>}`]: Endpoint;
    };
}
import Schema
                  BasePath extends string = '/'          
(type parameter) BasePath in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler
                >(
                  app:
(parameter) app: Hono<E, S, BasePath> Hono
(alias) class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = "/">
import Hono
The Hono class extends the functionality of the HonoBase class.
It sets up routing and allows for custom options to be passed.
@template E — The environment type.  
@template S — The schema type.  
@template BasePath — The base path type.<E,
(type parameter) E in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler S,
(type parameter) S in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler BasePath>          
(type parameter) BasePath in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): Handler
                ): Handler => {          
(alias) type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>
import Handler
                  // @ts-expect-error awslambda is not a standard API
                  return awslambda.streamifyResponse(
                    async (event:
(parameter) event: LambdaEvent LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent responseStream:
(parameter) responseStream: NodeJS.WritableStream NodeJS.WritableStream,
type NodeJS.WritableStream = /*unresolved*/ any context:
(parameter) context: LambdaContext LambdaContext) => {          
(alias) interface LambdaContext
import LambdaContext
Handler context parameter.
See AWS documentation.
                      const processor =
const processor: EventProcessor<LambdaEvent> getProcessor
const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>(event)          
(parameter) event: LambdaEvent
                      try {
                        const req =
const req: Request processor
const processor: EventProcessor<LambdaEvent>.createRequest
(method) EventProcessor<LambdaEvent>.createRequest(event: LambdaEvent): Request(event)          
(parameter) event: LambdaEvent
                        const requestContext =
const requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext getRequestContext
const getRequestContext: (event: LambdaEvent) => ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext(event)          
(parameter) event: LambdaEvent
                
                        const res = await
const res: Response app
(parameter) app: Hono<E, S, BasePath>.fetch
(property) Hono<E, S, BasePath>.fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: ExecutionContext) => Response | Promise<Response>
.fetch() will be entry point of your app.
@see — https://hono.dev/docs/api/hono#fetch  
@param request — request Object of request  
@param Env — env Object  
@param —  - context of execution  
@returns — response of request(req, {          
const req: Request
                          event,          
(property) event: LambdaEvent
                          requestContext,          
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                          context,          
(property) context: LambdaContext
                        })
                
                        const headers:
const headers: Record<string, string> Record = {}          
type Record<K extends keyof any, T> = { [P in K]: T; }
Construct a type with a set of properties K of type T
                        const cookies: string[] = []          
const cookies: string[]
                        res
const res: Response.headers
(property) Response.headers: Headers
MDN Reference.forEach(
(method) Headers.forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void(value,
(parameter) value: string name) => {          
(parameter) name: string
                          if (name === 'set-cookie') {          
(parameter) name: string
                            cookies
const cookies: string[].push
(method) Array<string>.push(...items: string[]): number
Appends new elements to the end of an array, and returns the new length of the array.
@param items — New elements to add to the array.(value)          
(parameter) value: string
                          } else {
                            headers
const headers: Record<string, string>[name] =
(parameter) name: string value          
(parameter) value: string
                          }
                        })
                
                        // Check content type
                        const httpResponseMetadata = {          
const httpResponseMetadata: {
    statusCode: number;
    headers: Record<string, string>;
    cookies: string[];
}
                          statusCode:
(property) statusCode: number res
const res: Response.status,          
(property) Response.status: number
MDN Reference
                          headers,          
(property) headers: Record<string, string>
                          cookies,          
(property) cookies: string[]
                        }
                
                        // Update response stream
                        // @ts-expect-error awslambda is not a standard API
                        responseStream = awslambda.HttpResponseStream.from
(parameter) responseStream: NodeJS.WritableStream(responseStream,
(parameter) responseStream: NodeJS.WritableStream httpResponseMetadata)          
const httpResponseMetadata: {
    statusCode: number;
    headers: Record<string, string>;
    cookies: string[];
}
                
                        if (res
const res: Response.body) {          
(property) Body.body: ReadableStream<Uint8Array> | null
MDN Reference
                          await streamToNodeStream
const streamToNodeStream: (reader: ReadableStreamDefaultReader<Uint8Array>, writer: NodeJS.WritableStream) => Promise<void>(res
const res: Response.body
(property) Body.body: ReadableStream<Uint8Array>
MDN Reference.getReader(),
(method) ReadableStream<Uint8Array>.getReader(): ReadableStreamDefaultReader<Uint8Array> (+2 overloads)
MDN Reference responseStream)          
(parameter) responseStream: NodeJS.WritableStream
                        } else {
                          responseStream.write('')          
(parameter) responseStream: NodeJS.WritableStream
                        }
                      } catch (error) {          
(local var) error: unknown
                        console
var console: Console.error('Error processing request:',
(method) Console.error(...data: any[]): void
MDN Reference error)          
(local var) error: unknown
                        responseStream.write('Internal Server Error')          
(parameter) responseStream: NodeJS.WritableStream
                      } finally {
                        responseStream.end()          
(parameter) responseStream: NodeJS.WritableStream
                      }
                    }
                  )
                }
                
                /**
                 * Accepts events from API Gateway/ELB(`APIGatewayProxyEvent`) and directly through Function Url(`APIGatewayProxyEventV2`)
                 */
                export const handle = 
const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>)
Accepts events from API Gateway/ELB(APIGatewayProxyEvent) and directly through Function Url(APIGatewayProxyEventV2)<E extends
(type parameter) E in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>) Env =
(alias) type Env = {
    Bindings?: Bindings;
    Variables?: Variables;
}
import Env Env,
(alias) type Env = {
    Bindings?: Bindings;
    Variables?: Variables;
}
import Env S extends
(type parameter) S in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>) Schema = {},
(alias) type Schema = {
    [Path: string]: {
        [Method: `$${Lowercase<string>}`]: Endpoint;
    };
}
import Schema BasePath extends string = '/'>(          
(type parameter) BasePath in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>)
                  app:
(parameter) app: Hono<E, S, BasePath> Hono
(alias) class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = "/">
import Hono
The Hono class extends the functionality of the HonoBase class.
It sets up routing and allows for custom options to be passed.
@template E — The environment type.  
@template S — The schema type.  
@template BasePath — The base path type.<E,
(type parameter) E in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>) S,
(type parameter) S in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>) BasePath>          
(type parameter) BasePath in <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>): ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>)
                ): ((event:
(parameter) event: LambdaEvent LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent lambdaContext?:
(parameter) lambdaContext: LambdaContext | undefined LambdaContext) =>
(alias) interface LambdaContext
import LambdaContext
Handler context parameter.
See AWS documentation. Promise
interface Promise<T>
Represents the completion of an asynchronous operation<APIGatewayProxyResult>) => {          
interface APIGatewayProxyResult
                  return async (event,
(parameter) event: LambdaEvent lambdaContext?) => {          
(parameter) lambdaContext: LambdaContext | undefined
                    const processor =
const processor: EventProcessor<LambdaEvent> getProcessor
const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>(event)          
(parameter) event: LambdaEvent
                
                    const req =
const req: Request processor
const processor: EventProcessor<LambdaEvent>.createRequest
(method) EventProcessor<LambdaEvent>.createRequest(event: LambdaEvent): Request(event)          
(parameter) event: LambdaEvent
                    const requestContext =
const requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext getRequestContext
const getRequestContext: (event: LambdaEvent) => ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext(event)          
(parameter) event: LambdaEvent
                
                    const res = await
const res: Response app
(parameter) app: Hono<E, S, BasePath>.fetch
(property) Hono<E, S, BasePath>.fetch: (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: ExecutionContext) => Response | Promise<Response>
.fetch() will be entry point of your app.
@see — https://hono.dev/docs/api/hono#fetch  
@param request — request Object of request  
@param Env — env Object  
@param —  - context of execution  
@returns — response of request(req, {          
const req: Request
                      event,          
(property) event: LambdaEvent
                      requestContext,          
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                      lambdaContext,          
(property) lambdaContext: LambdaContext | undefined
                    })
                
                    return processor
const processor: EventProcessor<LambdaEvent>.createResult
(method) EventProcessor<LambdaEvent>.createResult(event: LambdaEvent, res: Response): Promise<APIGatewayProxyResult>(event,
(parameter) event: LambdaEvent res)          
const res: Response
                  }
                }
                
                abstract class EventProcessor
class EventProcessor<E extends LambdaEvent><E extends
(type parameter) E in EventProcessor<E extends LambdaEvent> LambdaEvent> {          
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
                  protected abstract getPath
(method) EventProcessor<E extends LambdaEvent>.getPath(event: E): string(event:
(parameter) event: E extends LambdaEvent E): string          
(type parameter) E in EventProcessor<E extends LambdaEvent>
                
                  protected abstract getMethod
(method) EventProcessor<E extends LambdaEvent>.getMethod(event: E): string(event:
(parameter) event: E extends LambdaEvent E): string          
(type parameter) E in EventProcessor<E extends LambdaEvent>
                
                  protected abstract getQueryString
(method) EventProcessor<E extends LambdaEvent>.getQueryString(event: E): string(event:
(parameter) event: E extends LambdaEvent E): string          
(type parameter) E in EventProcessor<E extends LambdaEvent>
                
                  protected abstract getHeaders
(method) EventProcessor<E extends LambdaEvent>.getHeaders(event: E): Headers(event:
(parameter) event: E extends LambdaEvent E):
(type parameter) E in EventProcessor<E extends LambdaEvent> Headers          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                
                  protected abstract getCookies
(method) EventProcessor<E extends LambdaEvent>.getCookies(event: E, headers: Headers): void(event:
(parameter) event: E extends LambdaEvent E,
(type parameter) E in EventProcessor<E extends LambdaEvent> headers:
(parameter) headers: Headers Headers): void          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                
                  protected abstract setCookiesToResult(          
(method) EventProcessor<E extends LambdaEvent>.setCookiesToResult(event: E, result: APIGatewayProxyResult, cookies: string[]): void
                    event:
(parameter) event: E extends LambdaEvent E,          
(type parameter) E in EventProcessor<E extends LambdaEvent>
                    result:
(parameter) result: APIGatewayProxyResult APIGatewayProxyResult,          
interface APIGatewayProxyResult
                    cookies: string[]          
(parameter) cookies: string[]
                  ): void
                
                  createRequest
(method) EventProcessor<E extends LambdaEvent>.createRequest(event: E): Request(event:
(parameter) event: E extends LambdaEvent E):
(type parameter) E in EventProcessor<E extends LambdaEvent> Request {          
interface Request
This Fetch API interface represents a resource request.
MDN Reference
                    const queryString = this
const queryString: string.getQueryString
(method) EventProcessor<E extends LambdaEvent>.getQueryString(event: E): string(event)          
(parameter) event: E extends LambdaEvent
                    const domainName =          
const domainName: string | undefined
                      event
(parameter) event: LambdaEvent.requestContext && 'domainName' in
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext event
(parameter) event: LambdaEvent.requestContext          
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                        ? event
(parameter) event: LambdaEvent.requestContext
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2.domainName          
(property) domainName: string
                        : event
(parameter) event: LambdaEvent.headers?.['host'] ??
(property) headers?: Record<string, string | undefined> | undefined event
(parameter) event: LambdaEvent.multiValueHeaders?.['host']?.[0]          
(property) multiValueHeaders?: {
    [headerKey: string]: string[];
} | Record<string, string[] | undefined> | undefined
                    const path = this
const path: string.getPath
(method) EventProcessor<E extends LambdaEvent>.getPath(event: E): string(event)          
(parameter) event: E extends LambdaEvent
                    const urlPath = `https://$
const urlPath: string{domainName}$
const domainName: string | undefined{path}`          
const path: string
                    const url =
const url: string queryString ? `$
const queryString: string{urlPath}?$
const urlPath: string{queryString}` :
const queryString: string urlPath          
const urlPath: string
                
                    const headers = this
const headers: Headers.getHeaders
(method) EventProcessor<E extends LambdaEvent>.getHeaders(event: E): Headers(event)          
(parameter) event: E extends LambdaEvent
                
                    const method = this
const method: string.getMethod
(method) EventProcessor<E extends LambdaEvent>.getMethod(event: E): string(event)          
(parameter) event: E extends LambdaEvent
                    const requestInit:
const requestInit: RequestInit RequestInit = {          
interface RequestInit
                      headers,          
(property) RequestInit.headers?: HeadersInit | undefined
A Headers object, an object literal, or an array of two-item arrays to set request's headers.
                      method,          
(property) RequestInit.method?: string | undefined
A string to set request's method.
                    }
                
                    if (event
(parameter) event: LambdaEvent.body) {          
(property) body: string | null
                      requestInit
const requestInit: RequestInit.body =
(property) RequestInit.body?: BodyInit | null | undefined
A BodyInit object or null to set request's body. event
(parameter) event: LambdaEvent.isBase64Encoded ?
(property) isBase64Encoded: boolean decodeBase64
(alias) decodeBase64(str: string): Uint8Array
import decodeBase64(event
(parameter) event: LambdaEvent.body) :
(property) body: string event
(parameter) event: LambdaEvent.body          
(property) body: string
                    }
                
                    return new Request
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference(url,
const url: string requestInit)          
const requestInit: RequestInit
                  }
                
                  async createResult
(method) EventProcessor<E extends LambdaEvent>.createResult(event: E, res: Response): Promise<APIGatewayProxyResult>(event:
(parameter) event: E extends LambdaEvent E,
(type parameter) E in EventProcessor<E extends LambdaEvent> res:
(parameter) res: Response Response):
interface Response
This Fetch API interface represents the response to a request.
MDN Reference Promise
interface Promise<T>
Represents the completion of an asynchronous operation<APIGatewayProxyResult> {          
interface APIGatewayProxyResult
                    const contentType =
const contentType: string | null res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.get('content-type')          
(method) Headers.get(name: string): string | null
MDN Reference
                    let isBase64Encoded =
let isBase64Encoded: boolean contentType &&
const contentType: string | null isContentTypeBinary
const isContentTypeBinary: (contentType: string) => boolean(contentType) ? true : false          
const contentType: string
                
                    if (!isBase64Encoded) {          
let isBase64Encoded: boolean
                      const contentEncoding =
const contentEncoding: string | null res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.get('content-encoding')          
(method) Headers.get(name: string): string | null
MDN Reference
                      isBase64Encoded =
let isBase64Encoded: boolean isContentEncodingBinary
const isContentEncodingBinary: (contentEncoding: string | null) => boolean(contentEncoding)          
const contentEncoding: string | null
                    }
                
                    const body =
const body: string isBase64Encoded ?
let isBase64Encoded: boolean encodeBase64(await
(alias) encodeBase64(buf: ArrayBufferLike): string
import encodeBase64 res
(parameter) res: Response.arrayBuffer()) : await
(method) Body.arrayBuffer(): Promise<ArrayBuffer>
MDN Reference res
(parameter) res: Response.text()          
(method) Body.text(): Promise<string>
MDN Reference
                
                    const result:
const result: APIGatewayProxyResult APIGatewayProxyResult = {          
interface APIGatewayProxyResult
                      body:
(property) APIGatewayProxyResult.body: string body,          
const body: string
                      headers: {},          
(property) APIGatewayProxyResult.headers: Record<string, string>
                      multiValueHeaders:
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined event
(parameter) event: LambdaEvent.multiValueHeaders ? {} : undefined,          
(property) multiValueHeaders?: {
    [headerKey: string]: string[];
} | Record<string, string[] | undefined> | undefined
                      statusCode:
(property) APIGatewayProxyResult.statusCode: number res
(parameter) res: Response.status,          
(property) Response.status: number
MDN Reference
                      isBase64Encoded,          
(property) APIGatewayProxyResult.isBase64Encoded: boolean
                    }
                
                    this.setCookies
(method) EventProcessor<E extends LambdaEvent>.setCookies(event: E, res: Response, result: APIGatewayProxyResult): void(event,
(parameter) event: E extends LambdaEvent res,
(parameter) res: Response result)          
const result: APIGatewayProxyResult
                    res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.forEach(
(method) Headers.forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void(value,
(parameter) value: string key) => {          
(parameter) key: string
                      result
const result: APIGatewayProxyResult.headers
(property) APIGatewayProxyResult.headers: Record<string, string>[key] =
(parameter) key: string value          
(parameter) value: string
                      if (event
(parameter) event: LambdaEvent.multiValueHeaders &&
(property) multiValueHeaders?: {
    [headerKey: string]: string[];
} | Record<string, string[] | undefined> | undefined result
const result: APIGatewayProxyResult.multiValueHeaders) {          
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                        result
const result: APIGatewayProxyResult.multiValueHeaders
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
}[key] = 
(parameter) key: string[value]          
(parameter) value: string
                      }
                    })
                
                    return result          
const result: APIGatewayProxyResult
                  }
                
                  setCookies
(method) EventProcessor<E extends LambdaEvent>.setCookies(event: E, res: Response, result: APIGatewayProxyResult): void(event:
(parameter) event: E extends LambdaEvent E,
(type parameter) E in EventProcessor<E extends LambdaEvent> res:
(parameter) res: Response Response,
interface Response
This Fetch API interface represents the response to a request.
MDN Reference result:
(parameter) result: APIGatewayProxyResult APIGatewayProxyResult) {          
interface APIGatewayProxyResult
                    if (res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.has('set-cookie')) {          
(method) Headers.has(name: string): boolean
MDN Reference
                      const cookies =
const cookies: string[] res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.getSetCookie          
(method) Headers.getSetCookie(): string[]
MDN Reference
                        ? res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.getSetCookie()          
(method) Headers.getSetCookie(): string[]
MDN Reference
                        : Array
var Array: ArrayConstructor.from
(method) ArrayConstructor.from<[string, string]>(iterable: Iterable<[string, string]> | ArrayLike<[string, string]>): [string, string][] (+3 overloads)
Creates an array from an iterable object.
@param iterable — An iterable object to convert to an array.(res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.entries())          
(method) Headers.entries(): HeadersIterator<[string, string]>
Returns an iterator allowing to go through all key/value pairs contained in this object.
                            .filter((
(method) Array<[string, string]>.filter(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): [string, string][] (+1 overload)
Returns the elements of an array that meet the condition specified in a callback function.
@param predicate — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.[k]) =>
(parameter) k: string k === 'set-cookie')          
(parameter) k: string
                            .map(([,
(method) Array<[string, string]>.map<string>(callbackfn: (value: [string, string], index: number, array: [string, string][]) => string, thisArg?: any): string[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param callbackfn — A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. v]) =>
(parameter) v: string v)          
(parameter) v: string
                
                      if (Array
var Array: ArrayConstructor.isArray
(method) ArrayConstructor.isArray(arg: any): arg is any[](cookies)) {          
const cookies: string[]
                        this.setCookiesToResult
(method) EventProcessor<E extends LambdaEvent>.setCookiesToResult(event: E, result: APIGatewayProxyResult, cookies: string[]): void(event,
(parameter) event: E extends LambdaEvent result,
(parameter) result: APIGatewayProxyResult cookies)          
const cookies: string[]
                        res
(parameter) res: Response.headers
(property) Response.headers: Headers
MDN Reference.delete('set-cookie')          
(method) Headers.delete(name: string): void
MDN Reference
                      }
                    }
                  }
                }
                
                class EventV2Processor extends
class EventV2Processor EventProcessor
class EventProcessor<E extends LambdaEvent><APIGatewayProxyEventV2> {          
interface APIGatewayProxyEventV2
                  protected getPath
(method) EventV2Processor.getPath(event: APIGatewayProxyEventV2): string(event:
(parameter) event: APIGatewayProxyEventV2 APIGatewayProxyEventV2): string {          
interface APIGatewayProxyEventV2
                    return event
(parameter) event: APIGatewayProxyEventV2.rawPath          
(property) APIGatewayProxyEventV2.rawPath: string
                  }
                
                  protected getMethod
(method) EventV2Processor.getMethod(event: APIGatewayProxyEventV2): string(event:
(parameter) event: APIGatewayProxyEventV2 APIGatewayProxyEventV2): string {          
interface APIGatewayProxyEventV2
                    return event
(parameter) event: APIGatewayProxyEventV2.requestContext
(property) APIGatewayProxyEventV2.requestContext: ApiGatewayRequestContextV2.http
(property) ApiGatewayRequestContextV2.http: {
    method: string;
    path: string;
    protocol: string;
    sourceIp: string;
    userAgent: string;
}.method          
(property) method: string
                  }
                
                  protected getQueryString
(method) EventV2Processor.getQueryString(event: APIGatewayProxyEventV2): string(event:
(parameter) event: APIGatewayProxyEventV2 APIGatewayProxyEventV2): string {          
interface APIGatewayProxyEventV2
                    return event
(parameter) event: APIGatewayProxyEventV2.rawQueryString          
(property) APIGatewayProxyEventV2.rawQueryString: string
                  }
                
                  protected getCookies
(method) EventV2Processor.getCookies(event: APIGatewayProxyEventV2, headers: Headers): void(event:
(parameter) event: APIGatewayProxyEventV2 APIGatewayProxyEventV2,
interface APIGatewayProxyEventV2 headers:
(parameter) headers: Headers Headers): void {          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    if (Array
var Array: ArrayConstructor.isArray
(method) ArrayConstructor.isArray(arg: any): arg is any[](event
(parameter) event: APIGatewayProxyEventV2.cookies)) {          
(property) APIGatewayProxyEventV2.cookies?: string[] | undefined
                      headers
(parameter) headers: Headers.set('Cookie',
(method) Headers.set(name: string, value: string): void
MDN Reference event
(parameter) event: APIGatewayProxyEventV2.cookies
(property) APIGatewayProxyEventV2.cookies?: string[].join('; '))          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                    }
                  }
                
                  protected setCookiesToResult(          
(method) EventV2Processor.setCookiesToResult(_: APIGatewayProxyEventV2, result: APIGatewayProxyResult, cookies: string[]): void
                    _:
(parameter) _: APIGatewayProxyEventV2 APIGatewayProxyEventV2,          
interface APIGatewayProxyEventV2
                    result:
(parameter) result: APIGatewayProxyResult APIGatewayProxyResult,          
interface APIGatewayProxyResult
                    cookies: string[]          
(parameter) cookies: string[]
                  ): void {
                    result
(parameter) result: APIGatewayProxyResult.cookies =
(property) APIGatewayProxyResult.cookies?: string[] | undefined cookies          
(parameter) cookies: string[]
                  }
                
                  protected getHeaders
(method) EventV2Processor.getHeaders(event: APIGatewayProxyEventV2): Headers(event:
(parameter) event: APIGatewayProxyEventV2 APIGatewayProxyEventV2):
interface APIGatewayProxyEventV2 Headers {          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    const headers = new
const headers: Headers Headers()          
var Headers: new (init?: HeadersInit) => Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    this.getCookies
(method) EventV2Processor.getCookies(event: APIGatewayProxyEventV2, headers: Headers): void(event,
(parameter) event: APIGatewayProxyEventV2 headers)          
const headers: Headers
                    if (event
(parameter) event: APIGatewayProxyEventV2.headers) {          
(property) APIGatewayProxyEventV2.headers: Record<string, string | undefined>
                      for (const [k,
const k: string v] of
const v: string | undefined Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string | undefined>(o: {
    [s: string]: string | undefined;
} | ArrayLike<string | undefined>): [string, string | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: APIGatewayProxyEventV2.headers)) {          
(property) APIGatewayProxyEventV2.headers: Record<string, string | undefined>
                        if (v) {          
const v: string | undefined
                          headers
const headers: Headers.set
(method) Headers.set(name: string, value: string): void
MDN Reference(k,
const k: string v)          
const v: string
                        }
                      }
                    }
                    return headers          
const headers: Headers
                  }
                }
                
                const v2Processor:
const v2Processor: EventV2Processor EventV2Processor = new
class EventV2Processor EventV2Processor()          
constructor EventV2Processor<APIGatewayProxyEventV2>(): EventV2Processor
                
                class EventV1Processor extends
class EventV1Processor EventProcessor
class EventProcessor<E extends LambdaEvent><Exclude
type Exclude<T, U> = T extends U ? never : T
Exclude from T those types that are assignable to U<LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEventV2>> {          
interface APIGatewayProxyEventV2
                  protected getPath
(method) EventV1Processor.getPath(event: Exclude<LambdaEvent, APIGatewayProxyEventV2>): string(event:
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent Exclude
type Exclude<T, U> = T extends U ? never : T
Exclude from T those types that are assignable to U<LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEventV2>): string {          
interface APIGatewayProxyEventV2
                    return event
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent.path          
(property) path: string
                  }
                
                  protected getMethod
(method) EventV1Processor.getMethod(event: Exclude<LambdaEvent, APIGatewayProxyEventV2>): string(event:
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent Exclude
type Exclude<T, U> = T extends U ? never : T
Exclude from T those types that are assignable to U<LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEventV2>): string {          
interface APIGatewayProxyEventV2
                    return event
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent.httpMethod          
(property) httpMethod: string
                  }
                
                  protected getQueryString
(method) EventV1Processor.getQueryString(event: Exclude<LambdaEvent, APIGatewayProxyEventV2>): string(event:
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent Exclude
type Exclude<T, U> = T extends U ? never : T
Exclude from T those types that are assignable to U<LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEventV2>): string {          
interface APIGatewayProxyEventV2
                    return Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string | undefined>(o: {
    [s: string]: string | undefined;
} | ArrayLike<string | undefined>): [string, string | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent.queryStringParameters || {})          
(property) queryStringParameters?: Record<string, string | undefined> | undefined
                      .filter(([,
(method) Array<[string, string | undefined]>.filter(predicate: (value: [string, string | undefined], index: number, array: [string, string | undefined][]) => unknown, thisArg?: any): [string, string | undefined][] (+1 overload)
Returns the elements of an array that meet the condition specified in a callback function.
@param predicate — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. value]) =>
(parameter) value: string | undefined value)          
(parameter) value: string | undefined
                      .map((
(method) Array<[string, string | undefined]>.map<string>(callbackfn: (value: [string, string | undefined], index: number, array: [string, string | undefined][]) => string, thisArg?: any): string[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param callbackfn — A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.[key,
(parameter) key: string value]) => `$
(parameter) value: string | undefined{key}=$
(parameter) key: string{value}`)          
(parameter) value: string | undefined
                      .join('&')          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                  }
                
                  protected getCookies(          
(method) EventV1Processor.getCookies(event: Exclude<LambdaEvent, APIGatewayProxyEventV2>, headers: Headers): void
                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                    event:
(parameter) event: APIGatewayProxyEvent | ALBProxyEvent Exclude
type Exclude<T, U> = T extends U ? never : T
Exclude from T those types that are assignable to U<LambdaEvent,
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent APIGatewayProxyEventV2>,          
interface APIGatewayProxyEventV2
                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                    headers:
(parameter) headers: Headers Headers          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                  ): void {
                    // nop
                  }
                
                  protected getHeaders
(method) EventV1Processor.getHeaders(event: APIGatewayProxyEvent): Headers(event:
(parameter) event: APIGatewayProxyEvent APIGatewayProxyEvent):
interface APIGatewayProxyEvent Headers {          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    const headers = new
const headers: Headers Headers()          
var Headers: new (init?: HeadersInit) => Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    this.getCookies
(method) EventV1Processor.getCookies(event: Exclude<LambdaEvent, APIGatewayProxyEventV2>, headers: Headers): void(event,
(parameter) event: APIGatewayProxyEvent headers)          
const headers: Headers
                    if (event
(parameter) event: APIGatewayProxyEvent.headers) {          
(property) APIGatewayProxyEvent.headers: Record<string, string | undefined>
                      for (const [k,
const k: string v] of
const v: string | undefined Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string | undefined>(o: {
    [s: string]: string | undefined;
} | ArrayLike<string | undefined>): [string, string | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: APIGatewayProxyEvent.headers)) {          
(property) APIGatewayProxyEvent.headers: Record<string, string | undefined>
                        if (v) {          
const v: string | undefined
                          headers
const headers: Headers.set
(method) Headers.set(name: string, value: string): void
MDN Reference(k,
const k: string v)          
const v: string
                        }
                      }
                    }
                    if (event
(parameter) event: APIGatewayProxyEvent.multiValueHeaders) {          
(property) APIGatewayProxyEvent.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                      for (const [k,
const k: string values] of
const values: string[] Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string[]>(o: {
    [s: string]: string[];
} | ArrayLike<string[]>): [string, string[]][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: APIGatewayProxyEvent.multiValueHeaders)) {          
(property) APIGatewayProxyEvent.multiValueHeaders?: {
    [headerKey: string]: string[];
}
                        if (values) {          
const values: string[]
                          // avoid duplicating already set headers
                          const foundK =
const foundK: string | null headers
const headers: Headers.get
(method) Headers.get(name: string): string | null
MDN Reference(k)          
const k: string
                          values
const values: string[].forEach(
(method) Array<string>.forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void
Performs the specified action for each element in an array.
@param callbackfn — A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.(v) => (
(parameter) v: string!foundK || 
const foundK: string | null!foundK
const foundK: string.includes
(method) String.includes(searchString: string, position?: number): boolean
Returns true if searchString appears as a substring of the result of converting this
object to a String, at one or more positions that are
greater than or equal to position; otherwise, returns false.
@param searchString — search string  
@param position — If position is undefined, 0 is assumed, so as to search all of the String.(v)) &&
(parameter) v: string headers
const headers: Headers.append
(method) Headers.append(name: string, value: string): void
MDN Reference(k,
const k: string v))          
(parameter) v: string
                        }
                      }
                    }
                    return headers          
const headers: Headers
                  }
                
                  protected setCookiesToResult(          
(method) EventV1Processor.setCookiesToResult(_: APIGatewayProxyEvent, result: APIGatewayProxyResult, cookies: string[]): void
                    _:
(parameter) _: APIGatewayProxyEvent APIGatewayProxyEvent,          
interface APIGatewayProxyEvent
                    result:
(parameter) result: APIGatewayProxyResult APIGatewayProxyResult,          
interface APIGatewayProxyResult
                    cookies: string[]          
(parameter) cookies: string[]
                  ): void {
                    result
(parameter) result: APIGatewayProxyResult.multiValueHeaders = {          
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                      'set-cookie': cookies,          
(parameter) cookies: string[]
                    }
                  }
                }
                
                const v1Processor:
const v1Processor: EventV1Processor EventV1Processor = new
class EventV1Processor EventV1Processor()          
constructor EventV1Processor<APIGatewayProxyEvent | ALBProxyEvent>(): EventV1Processor
                
                class ALBProcessor extends
class ALBProcessor EventProcessor
class EventProcessor<E extends LambdaEvent><ALBProxyEvent> {          
interface ALBProxyEvent
                  protected getHeaders
(method) ALBProcessor.getHeaders(event: ALBProxyEvent): Headers(event:
(parameter) event: ALBProxyEvent ALBProxyEvent):
interface ALBProxyEvent Headers {          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    const headers = new
const headers: Headers Headers()          
var Headers: new (init?: HeadersInit) => Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    // if multiValueHeaders is present the ALB will use it instead of the headers field
                    // https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html#multi-value-headers
                    if (event
(parameter) event: ALBProxyEvent.multiValueHeaders) {          
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined> | undefined
                      for (const [key,
const key: string values] of
const values: string[] | undefined Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string[] | undefined>(o: {
    [s: string]: string[] | undefined;
} | ArrayLike<string[] | undefined>): [string, string[] | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: ALBProxyEvent.multiValueHeaders)) {          
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined>
                        if (values &&
const values: string[] | undefined Array
var Array: ArrayConstructor.isArray
(method) ArrayConstructor.isArray(arg: any): arg is any[](values)) {          
const values: string[]
                          // https://www.rfc-editor.org/rfc/rfc9110.html#name-common-rules-for-defining-f
                          headers
const headers: Headers.set
(method) Headers.set(name: string, value: string): void
MDN Reference(key,
const key: string values
const values: string[].join('; '))          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                        }
                      }
                    } else {
                      for (const [key,
const key: string value] of
const value: string | undefined Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string | undefined>(o: {
    [s: string]: string | undefined;
} | ArrayLike<string | undefined>): [string, string | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: ALBProxyEvent.headers ?? {})) {          
(property) ALBProxyEvent.headers?: Record<string, string | undefined> | undefined
                        if (value) {          
const value: string | undefined
                          headers
const headers: Headers.set
(method) Headers.set(name: string, value: string): void
MDN Reference(key,
const key: string value)          
const value: string
                        }
                      }
                    }
                    return headers          
const headers: Headers
                  }
                
                  protected getPath
(method) ALBProcessor.getPath(event: ALBProxyEvent): string(event:
(parameter) event: ALBProxyEvent ALBProxyEvent): string {          
interface ALBProxyEvent
                    return event
(parameter) event: ALBProxyEvent.path          
(property) ALBProxyEvent.path: string
                  }
                
                  protected getMethod
(method) ALBProcessor.getMethod(event: ALBProxyEvent): string(event:
(parameter) event: ALBProxyEvent ALBProxyEvent): string {          
interface ALBProxyEvent
                    return event
(parameter) event: ALBProxyEvent.httpMethod          
(property) ALBProxyEvent.httpMethod: string
                  }
                
                  protected getQueryString
(method) ALBProcessor.getQueryString(event: ALBProxyEvent): string(event:
(parameter) event: ALBProxyEvent ALBProxyEvent): string {          
interface ALBProxyEvent
                    // In the case of ALB Integration either queryStringParameters or multiValueQueryStringParameters can be present not both
                    /* 
                      In other cases like when using the serverless framework, the event object does contain both queryStringParameters and multiValueQueryStringParameters:
                      Below is an example event object for this URL: /payment/b8c55e69?select=amount&select=currency
                      {
                        ...
                        queryStringParameters: { select: 'currency' },
                        multiValueQueryStringParameters: { select: [ 'amount', 'currency' ] },
                      }
                      The expected results is for select to be an array with two items. However the pre-fix code is only returning one item ('currency') in the array.
                      A simple fix would be to invert the if statement and check the multiValueQueryStringParameters first.
                    */
                    if (event
(parameter) event: ALBProxyEvent.multiValueQueryStringParameters) {          
(property) ALBProxyEvent.multiValueQueryStringParameters?: {
    [parameterKey: string]: string[];
} | undefined
                      return Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string[]>(o: {
    [s: string]: string[];
} | ArrayLike<string[]>): [string, string[]][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: ALBProxyEvent.multiValueQueryStringParameters || {})          
(property) ALBProxyEvent.multiValueQueryStringParameters?: {
    [parameterKey: string]: string[];
}
                        .filter(([,
(method) Array<[string, string[]]>.filter(predicate: (value: [string, string[]], index: number, array: [string, string[]][]) => unknown, thisArg?: any): [string, string[]][] (+1 overload)
Returns the elements of an array that meet the condition specified in a callback function.
@param predicate — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. value]) =>
(parameter) value: string[] value)          
(parameter) value: string[]
                        .map((
(method) Array<[string, string[]]>.map<string>(callbackfn: (value: [string, string[]], index: number, array: [string, string[]][]) => string, thisArg?: any): string[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param callbackfn — A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.[key,
(parameter) key: string value]) => `$
(parameter) value: string[]{key}=$
(parameter) key: string{value
(parameter) value: string[].join(`&$
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.{key}=`)}`)          
(parameter) key: string
                        .join('&')          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                    } else {
                      return Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..entries
(method) ObjectConstructor.entries<string | undefined>(o: {
    [s: string]: string | undefined;
} | ArrayLike<string | undefined>): [string, string | undefined][] (+1 overload)
Returns an array of key/values of the enumerable own properties of an object
@param o — Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.(event
(parameter) event: ALBProxyEvent.queryStringParameters || {})          
(property) ALBProxyEvent.queryStringParameters?: Record<string, string | undefined> | undefined
                        .filter(([,
(method) Array<[string, string | undefined]>.filter(predicate: (value: [string, string | undefined], index: number, array: [string, string | undefined][]) => unknown, thisArg?: any): [string, string | undefined][] (+1 overload)
Returns the elements of an array that meet the condition specified in a callback function.
@param predicate — A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. value]) =>
(parameter) value: string | undefined value)          
(parameter) value: string | undefined
                        .map((
(method) Array<[string, string | undefined]>.map<string>(callbackfn: (value: [string, string | undefined], index: number, array: [string, string | undefined][]) => string, thisArg?: any): string[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param callbackfn — A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.  
@param thisArg — An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.[key,
(parameter) key: string value]) => `$
(parameter) value: string | undefined{key}=$
(parameter) key: string{value}`)          
(parameter) value: string | undefined
                        .join('&')          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                    }
                  }
                
                  protected getCookies
(method) ALBProcessor.getCookies(event: ALBProxyEvent, headers: Headers): void(event:
(parameter) event: ALBProxyEvent ALBProxyEvent,
interface ALBProxyEvent headers:
(parameter) headers: Headers Headers): void {          
interface Headers
This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence.
MDN Reference
                    let cookie          
let cookie: any
                    if (event
(parameter) event: ALBProxyEvent.multiValueHeaders) {          
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined> | undefined
                      cookie =
let cookie: any event
(parameter) event: ALBProxyEvent.multiValueHeaders['cookie']?
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined>.join('; ')          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                    } else {
                      cookie =
let cookie: any event
(parameter) event: ALBProxyEvent.headers ?
(property) ALBProxyEvent.headers?: Record<string, string | undefined> | undefined event
(parameter) event: ALBProxyEvent.headers['cookie'] : undefined          
(property) ALBProxyEvent.headers?: Record<string, string | undefined>
                    }
                    if (cookie) {          
let cookie: string | undefined
                      headers
(parameter) headers: Headers.append('Cookie',
(method) Headers.append(name: string, value: string): void
MDN Reference cookie)          
let cookie: string
                    }
                  }
                
                  protected setCookiesToResult(          
(method) ALBProcessor.setCookiesToResult(event: ALBProxyEvent, result: APIGatewayProxyResult, cookies: string[]): void
                    event:
(parameter) event: ALBProxyEvent ALBProxyEvent,          
interface ALBProxyEvent
                    result:
(parameter) result: APIGatewayProxyResult APIGatewayProxyResult,          
interface APIGatewayProxyResult
                    cookies: string[]          
(parameter) cookies: string[]
                  ): void {
                    // when multi value headers is enabled
                    if (event
(parameter) event: ALBProxyEvent.multiValueHeaders &&
(property) ALBProxyEvent.multiValueHeaders?: Record<string, string[] | undefined> | undefined result
(parameter) result: APIGatewayProxyResult.multiValueHeaders) {          
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} | undefined
                      result
(parameter) result: APIGatewayProxyResult.multiValueHeaders['set-cookie'] =
(property) APIGatewayProxyResult.multiValueHeaders?: {
    [headerKey: string]: string[];
} cookies          
(parameter) cookies: string[]
                    } else {
                      // otherwise serialize the set-cookie
                      result
(parameter) result: APIGatewayProxyResult.headers['set-cookie'] =
(property) APIGatewayProxyResult.headers: Record<string, string> cookies
(parameter) cookies: string[].join(', ')          
(method) Array<string>.join(separator?: string): string
Adds all the elements of an array into a string, separated by the specified separator string.
@param separator — A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
                    }
                  }
                }
                
                const albProcessor:
const albProcessor: ALBProcessor ALBProcessor = new
class ALBProcessor ALBProcessor()          
constructor ALBProcessor<ALBProxyEvent>(): ALBProcessor
                
                export const getProcessor = 
const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>(event:
(parameter) event: LambdaEvent LambdaEvent):
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent EventProcessor
class EventProcessor<E extends LambdaEvent><LambdaEvent> => {          
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
                  if (isProxyEventALB
const isProxyEventALB: (event: LambdaEvent) => event is ALBProxyEvent(event)) {          
(parameter) event: LambdaEvent
                    return albProcessor          
const albProcessor: ALBProcessor
                  }
                  if (isProxyEventV2
const isProxyEventV2: (event: LambdaEvent) => event is APIGatewayProxyEventV2(event)) {          
(parameter) event: APIGatewayProxyEvent | APIGatewayProxyEventV2
                    return v2Processor          
const v2Processor: EventV2Processor
                  }
                  return v1Processor          
const v1Processor: EventV1Processor
                }
                
                const isProxyEventALB = 
const isProxyEventALB: (event: LambdaEvent) => event is ALBProxyEvent(event:
(parameter) event: LambdaEvent LambdaEvent):
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent event is
(parameter) event: LambdaEvent ALBProxyEvent => {          
interface ALBProxyEvent
                  return Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..hasOwn
(method) ObjectConstructor.hasOwn(o: object, v: PropertyKey): boolean
Determines whether an object has a property with the specified name.
@param o — An object.  
@param v — A property name.(event
(parameter) event: LambdaEvent.requestContext, 'elb')          
(property) requestContext: ApiGatewayRequestContext | ApiGatewayRequestContextV2 | ALBRequestContext
                }
                
                const isProxyEventV2 = 
const isProxyEventV2: (event: LambdaEvent) => event is APIGatewayProxyEventV2(event:
(parameter) event: LambdaEvent LambdaEvent):
type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent event is
(parameter) event: LambdaEvent APIGatewayProxyEventV2 => {          
interface APIGatewayProxyEventV2
                  return Object
var Object: ObjectConstructor
Provides functionality common to all JavaScript objects..hasOwn
(method) ObjectConstructor.hasOwn(o: object, v: PropertyKey): boolean
Determines whether an object has a property with the specified name.
@param o — An object.  
@param v — A property name.(event, 'rawPath')          
(parameter) event: LambdaEvent
                }
                
                export const isContentTypeBinary = 
const isContentTypeBinary: (contentType: string) => boolean(contentType: string) => {          
(parameter) contentType: string
                  return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(          
(method) RegExp.test(string: string): boolean
Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
@param string — String on which to perform the search.
                    contentType          
(parameter) contentType: string
                  )
                }
                
                export const isContentEncodingBinary = 
const isContentEncodingBinary: (contentEncoding: string | null) => boolean(contentEncoding: string | null) => {          
(parameter) contentEncoding: string | null
                  if (contentEncoding === null) {          
(parameter) contentEncoding: string | null
                    return false
                  }
                  return /^(gzip|deflate|compress|br)/.test
(method) RegExp.test(string: string): boolean
Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
@param string — String on which to perform the search.(contentEncoding)          
(parameter) contentEncoding: string
                }
            

            
                /**
                 * @module
                 * AWS Lambda Adapter for Hono.
                 */
                
                export { handle,
(alias) const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>)
export handle
Accepts events from API Gateway/ELB(APIGatewayProxyEvent) and directly through Function Url(APIGatewayProxyEventV2) streamHandle } from './handler'          
(alias) const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => Handler
export streamHandle
                export type { APIGatewayProxyResult,
(alias) interface APIGatewayProxyResult
export APIGatewayProxyResult LambdaEvent } from './handler'          
(alias) type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent
export LambdaEvent
                export type {
                  ApiGatewayRequestContext,          
(alias) interface ApiGatewayRequestContext
export ApiGatewayRequestContext
                  ApiGatewayRequestContextV2,          
(alias) interface ApiGatewayRequestContextV2
export ApiGatewayRequestContextV2
                  ALBRequestContext,          
(alias) interface ALBRequestContext
export ALBRequestContext
                  LambdaContext,          
(alias) interface LambdaContext
export LambdaContext
Handler context parameter.
See AWS documentation.
                } from './types'
            

            
                /* eslint-disable @typescript-eslint/no-explicit-any */
                
                export interface CognitoIdentity {          
interface CognitoIdentity
                  cognitoIdentityId: string          
(property) CognitoIdentity.cognitoIdentityId: string
                  cognitoIdentityPoolId: string          
(property) CognitoIdentity.cognitoIdentityPoolId: string
                }
                
                export interface ClientContext {          
interface ClientContext
                  client:
(property) ClientContext.client: ClientContextClient ClientContextClient          
interface ClientContextClient
                
                  Custom?: any          
(property) ClientContext.Custom?: any
                  env:
(property) ClientContext.env: ClientContextEnv ClientContextEnv          
interface ClientContextEnv
                }
                
                export interface ClientContextClient {          
interface ClientContextClient
                  installationId: string          
(property) ClientContextClient.installationId: string
                  appTitle: string          
(property) ClientContextClient.appTitle: string
                  appVersionName: string          
(property) ClientContextClient.appVersionName: string
                  appVersionCode: string          
(property) ClientContextClient.appVersionCode: string
                  appPackageName: string          
(property) ClientContextClient.appPackageName: string
                }
                
                export interface ClientContextEnv {          
interface ClientContextEnv
                  platformVersion: string          
(property) ClientContextEnv.platformVersion: string
                  platform: string          
(property) ClientContextEnv.platform: string
                  make: string          
(property) ClientContextEnv.make: string
                  model: string          
(property) ClientContextEnv.model: string
                  locale: string          
(property) ClientContextEnv.locale: string
                }
                
                /**
                 * {@link Handler} context parameter.
                 * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
                 */
                export interface LambdaContext {          
interface LambdaContext
Handler context parameter.
See AWS documentation.
                  callbackWaitsForEmptyEventLoop: boolean          
(property) LambdaContext.callbackWaitsForEmptyEventLoop: boolean
                  functionName: string          
(property) LambdaContext.functionName: string
                  functionVersion: string          
(property) LambdaContext.functionVersion: string
                  invokedFunctionArn: string          
(property) LambdaContext.invokedFunctionArn: string
                  memoryLimitInMB: string          
(property) LambdaContext.memoryLimitInMB: string
                  awsRequestId: string          
(property) LambdaContext.awsRequestId: string
                  logGroupName: string          
(property) LambdaContext.logGroupName: string
                  logStreamName: string          
(property) LambdaContext.logStreamName: string
                  identity?:
(property) LambdaContext.identity?: CognitoIdentity | undefined CognitoIdentity | undefined          
interface CognitoIdentity
                  clientContext?:
(property) LambdaContext.clientContext?: ClientContext | undefined ClientContext | undefined          
interface ClientContext
                
                  getRemainingTimeInMillis(): number          
(method) LambdaContext.getRemainingTimeInMillis(): number
                }
                
                type Callback
type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void<TResult = any> = 
(type parameter) TResult in type Callback<TResult = any>(error?:
(parameter) error: string | Error | null | undefined Error | string | null,
interface Error result?:
(parameter) result: TResult | undefined TResult) => void          
(type parameter) TResult in type Callback<TResult = any>
                
                export type Handler
type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult><TEvent = any,
(type parameter) TEvent in type Handler<TEvent = any, TResult = any> TResult = any> = (          
(type parameter) TResult in type Handler<TEvent = any, TResult = any>
                  event:
(parameter) event: TEvent = any TEvent,          
(type parameter) TEvent in type Handler<TEvent = any, TResult = any>
                  context:
(parameter) context: LambdaContext LambdaContext,          
interface LambdaContext
Handler context parameter.
See AWS documentation.
                  callback:
(parameter) callback: Callback<TResult> Callback
type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void<TResult>          
(type parameter) TResult in type Handler<TEvent = any, TResult = any>
                ) => void | Promise
interface Promise<T>
Represents the completion of an asynchronous operation<TResult>          
(type parameter) TResult in type Handler<TEvent = any, TResult = any>
                
                interface ClientCert {          
interface ClientCert
                  clientCertPem: string          
(property) ClientCert.clientCertPem: string
                  subjectDN: string          
(property) ClientCert.subjectDN: string
                  issuerDN: string          
(property) ClientCert.issuerDN: string
                  serialNumber: string          
(property) ClientCert.serialNumber: string
                  validity: {          
(property) ClientCert.validity: {
    notBefore: string;
    notAfter: string;
}
                    notBefore: string          
(property) notBefore: string
                    notAfter: string          
(property) notAfter: string
                  }
                }
                
                interface Identity {          
interface Identity
                  accessKey?: string          
(property) Identity.accessKey?: string | undefined
                  accountId?: string          
(property) Identity.accountId?: string | undefined
                  caller?: string          
(property) Identity.caller?: string | undefined
                  cognitoAuthenticationProvider?: string          
(property) Identity.cognitoAuthenticationProvider?: string | undefined
                  cognitoAuthenticationType?: string          
(property) Identity.cognitoAuthenticationType?: string | undefined
                  cognitoIdentityId?: string          
(property) Identity.cognitoIdentityId?: string | undefined
                  cognitoIdentityPoolId?: string          
(property) Identity.cognitoIdentityPoolId?: string | undefined
                  principalOrgId?: string          
(property) Identity.principalOrgId?: string | undefined
                  sourceIp: string          
(property) Identity.sourceIp: string
                  user?: string          
(property) Identity.user?: string | undefined
                  userAgent: string          
(property) Identity.userAgent: string
                  userArn?: string          
(property) Identity.userArn?: string | undefined
                  clientCert?:
(property) Identity.clientCert?: ClientCert | undefined ClientCert          
interface ClientCert
                }
                
                export interface ApiGatewayRequestContext {          
interface ApiGatewayRequestContext
                  accountId: string          
(property) ApiGatewayRequestContext.accountId: string
                  apiId: string          
(property) ApiGatewayRequestContext.apiId: string
                  authorizer: {          
(property) ApiGatewayRequestContext.authorizer: {
    claims?: unknown;
    scopes?: unknown;
}
                    claims?: unknown          
(property) claims?: unknown
                    scopes?: unknown          
(property) scopes?: unknown
                  }
                  domainName: string          
(property) ApiGatewayRequestContext.domainName: string
                  domainPrefix: string          
(property) ApiGatewayRequestContext.domainPrefix: string
                  extendedRequestId: string          
(property) ApiGatewayRequestContext.extendedRequestId: string
                  httpMethod: string          
(property) ApiGatewayRequestContext.httpMethod: string
                  identity:
(property) ApiGatewayRequestContext.identity: Identity Identity          
interface Identity
                  path: string          
(property) ApiGatewayRequestContext.path: string
                  protocol: string          
(property) ApiGatewayRequestContext.protocol: string
                  requestId: string          
(property) ApiGatewayRequestContext.requestId: string
                  requestTime: string          
(property) ApiGatewayRequestContext.requestTime: string
                  requestTimeEpoch: number          
(property) ApiGatewayRequestContext.requestTimeEpoch: number
                  resourceId?: string          
(property) ApiGatewayRequestContext.resourceId?: string | undefined
                  resourcePath: string          
(property) ApiGatewayRequestContext.resourcePath: string
                  stage: string          
(property) ApiGatewayRequestContext.stage: string
                }
                
                interface Authorizer {          
interface Authorizer
                  iam?: {          
(property) Authorizer.iam?: {
    accessKey: string;
    accountId: string;
    callerId: string;
    cognitoIdentity: null;
    principalOrgId: null;
    userArn: string;
    userId: string;
} | undefined
                    accessKey: string          
(property) accessKey: string
                    accountId: string          
(property) accountId: string
                    callerId: string          
(property) callerId: string
                    cognitoIdentity: null          
(property) cognitoIdentity: null
                    principalOrgId: null          
(property) principalOrgId: null
                    userArn: string          
(property) userArn: string
                    userId: string          
(property) userId: string
                  }
                }
                
                export interface ApiGatewayRequestContextV2 {          
interface ApiGatewayRequestContextV2
                  accountId: string          
(property) ApiGatewayRequestContextV2.accountId: string
                  apiId: string          
(property) ApiGatewayRequestContextV2.apiId: string
                  authentication: null          
(property) ApiGatewayRequestContextV2.authentication: null
                  authorizer:
(property) ApiGatewayRequestContextV2.authorizer: Authorizer Authorizer          
interface Authorizer
                  domainName: string          
(property) ApiGatewayRequestContextV2.domainName: string
                  domainPrefix: string          
(property) ApiGatewayRequestContextV2.domainPrefix: string
                  http: {          
(property) ApiGatewayRequestContextV2.http: {
    method: string;
    path: string;
    protocol: string;
    sourceIp: string;
    userAgent: string;
}
                    method: string          
(property) method: string
                    path: string          
(property) path: string
                    protocol: string          
(property) protocol: string
                    sourceIp: string          
(property) sourceIp: string
                    userAgent: string          
(property) userAgent: string
                  }
                  requestId: string          
(property) ApiGatewayRequestContextV2.requestId: string
                  routeKey: string          
(property) ApiGatewayRequestContextV2.routeKey: string
                  stage: string          
(property) ApiGatewayRequestContextV2.stage: string
                  time: string          
(property) ApiGatewayRequestContextV2.time: string
                  timeEpoch: number          
(property) ApiGatewayRequestContextV2.timeEpoch: number
                }
                
                export interface ALBRequestContext {          
interface ALBRequestContext
                  elb: {          
(property) ALBRequestContext.elb: {
    targetGroupArn: string;
}
                    targetGroupArn: string          
(property) targetGroupArn: string
                  }
                }
            

            
                import { Context } from '../../context'
                import type { AddressType } from '../../helper/conninfo'
                import { getConnInfo } from './conninfo'
                
                const createRandomBunServer = ({          
const createRandomBunServer: ({ address, port, family, }?: {
    address?: string;
    port?: number;
    family?: AddressType | string;
}) => {
    address: string;
    port: number;
    server: {
        requestIP(): {
            address: string;
            family: string;
            port: number;
        };
    };
}
                  address =
(parameter) address: string Math
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants..random()
(method) Math.random(): number
Returns a pseudorandom number between 0 and 1..toString(),          
(method) Number.toString(radix?: number): string
Returns a string representation of an object.
@param radix — Specifies a radix for converting numeric values to strings. This value is only used for numbers.
                  port =
(parameter) port: number Math
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants..floor
(method) Math.floor(x: number): number
Returns the greatest integer less than or equal to its numeric argument.
@param x — A numeric expression.(Math
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants..random() * (65535 + 1)),          
(method) Math.random(): number
Returns a pseudorandom number between 0 and 1.
                  family = 'IPv6',          
(parameter) family: string
                }: {
                  address?: string          
(property) address?: string | undefined
                  port?: number          
(property) port?: number | undefined
                  family?:
(property) family?: string | undefined AddressType | string          
(alias) type AddressType = "IPv6" | "IPv4" | undefined
import AddressType
                } = {}) => {
                  return {
                    address,          
(property) address: string
                    port,          
(property) port: number
                    server: {          
(property) server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
}
                      requestIP() {          
(method) requestIP(): {
    address: string;
    family: string;
    port: number;
}
                        return {
                          address,          
(property) address: string
                          family,          
(property) family: string
                          port,          
(property) port: number
                        }
                      },
                    },
                  }
                }
                describe('getConnInfo', () => {
                  it('Should info is valid', () => {
                    const { port,
const port: number server,
const server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
} address } =
const address: string createRandomBunServer()          
const createRandomBunServer: ({ address, port, family, }?: {
    address?: string;
    port?: number;
    family?: AddressType | string;
}) => {
    address: string;
    port: number;
    server: {
        requestIP(): {
            address: string;
            family: string;
            port: number;
        };
    };
}
                    const c = new
const c: Context<any, any, {}> Context(new
(alias) new Context<any, any, {}>(req: Request, options?: ContextOptions<any> | undefined): Context<any, any, {}>
import Context
Creates an instance of the Context class.
@param req — The Request object.  
@param options — Optional configuration options for the context. Request('http://localhost/'), {
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference env:
(property) env: any
Bindings for the environment. server })          
const server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
}
                    const info =
const info: ConnInfo getConnInfo
(alias) getConnInfo(c: Context): ConnInfo
import getConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo(c)          
const c: Context<any, any, {}>
                
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.port).toBe
(property) port?: number | undefined
Transport port number(port)          
const port: number
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.address).toBe
(property) address?: string | undefined
Host name such as IP Addr(address)          
const address: string
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.addressType).toBe('IPv6')          
(property) addressType?: AddressType
Host name type
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.transport).toBeUndefined()          
(property) transport?: "tcp" | "udp" | undefined
Transport protocol type
                  })
                  it('Should getConnInfo works when env is { server: server }', () => {
                    const { port,
const port: number server,
const server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
} address } =
const address: string createRandomBunServer()          
const createRandomBunServer: ({ address, port, family, }?: {
    address?: string;
    port?: number;
    family?: AddressType | string;
}) => {
    address: string;
    port: number;
    server: {
        requestIP(): {
            address: string;
            family: string;
            port: number;
        };
    };
}
                    const c = new
const c: Context<any, any, {}> Context(new
(alias) new Context<any, any, {}>(req: Request, options?: ContextOptions<any> | undefined): Context<any, any, {}>
import Context
Creates an instance of the Context class.
@param req — The Request object.  
@param options — Optional configuration options for the context. Request('http://localhost/'), {
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference env: {
(property) env: any
Bindings for the environment. server } })          
(property) server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
}
                
                    const info =
const info: ConnInfo getConnInfo
(alias) getConnInfo(c: Context): ConnInfo
import getConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo(c)          
const c: Context<any, any, {}>
                
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.port).toBe
(property) port?: number | undefined
Transport port number(port)          
const port: number
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.address).toBe
(property) address?: string | undefined
Host name such as IP Addr(address)          
const address: string
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.addressType).toBe('IPv6')          
(property) addressType?: AddressType
Host name type
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.transport).toBeUndefined()          
(property) transport?: "tcp" | "udp" | undefined
Transport protocol type
                  })
                  it('should return undefined when addressType is invalid string', () => {
                    const { server } =
const server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
} createRandomBunServer({
const createRandomBunServer: ({ address, port, family, }?: {
    address?: string;
    port?: number;
    family?: AddressType | string;
}) => {
    address: string;
    port: number;
    server: {
        requestIP(): {
            address: string;
            family: string;
            port: number;
        };
    };
} family: 'invalid' })          
(property) family?: string | undefined
                    const c = new
const c: Context<any, any, {}> Context(new
(alias) new Context<any, any, {}>(req: Request, options?: ContextOptions<any> | undefined): Context<any, any, {}>
import Context
Creates an instance of the Context class.
@param req — The Request object.  
@param options — Optional configuration options for the context. Request('http://localhost/'), {
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference env: {
(property) env: any
Bindings for the environment. server } })          
(property) server: {
    requestIP(): {
        address: string;
        family: string;
        port: number;
    };
}
                
                    const info =
const info: ConnInfo getConnInfo
(alias) getConnInfo(c: Context): ConnInfo
import getConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo(c)          
const c: Context<any, any, {}>
                
                    expect(info
const info: ConnInfo.remote
(property) ConnInfo.remote: NetAddrInfo
Remote information.addressType).toBeUndefined()          
(property) addressType?: AddressType
Host name type
                  })
                  it('Should throw error when user did not give server', () => {
                    const c = new
const c: Context<any, any, {}> Context(new
(alias) new Context<any, any, {}>(req: Request, options?: ContextOptions<any> | undefined): Context<any, any, {}>
import Context
Creates an instance of the Context class.
@param req — The Request object.  
@param options — Optional configuration options for the context. Request('http://localhost/'), {
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference env: {} })          
(property) env: any
Bindings for the environment.
                
                    expect(() => getConnInfo
(alias) getConnInfo(c: Context): ConnInfo
import getConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo(c)).toThrowError
const c: Context<any, any, {}>(TypeError)          
var TypeError: TypeErrorConstructor
                  })
                  it('Should throw error when requestIP is not function', () => {
                    const c = new
const c: Context<any, any, {}> Context(new
(alias) new Context<any, any, {}>(req: Request, options?: ContextOptions<any> | undefined): Context<any, any, {}>
import Context
Creates an instance of the Context class.
@param req — The Request object.  
@param options — Optional configuration options for the context. Request('http://localhost/'), {          
var Request: new (input: RequestInfo | URL, init?: RequestInit) => Request
This Fetch API interface represents a resource request.
MDN Reference
                      env: {          
(property) env: any
Bindings for the environment.
                        requestIP: 0,          
(property) requestIP: number
                      },
                    })
                    expect(() => getConnInfo
(alias) getConnInfo(c: Context): ConnInfo
import getConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo(c)).toThrowError
const c: Context<any, any, {}>(TypeError)          
var TypeError: TypeErrorConstructor
                  })
                })
            

            
                import type { Context } from '../..'
                import type { GetConnInfo } from '../../helper/conninfo'
                import { getBunServer } from './server'
                
                /**
                 * Get ConnInfo with Bun
                 * @param c Context
                 * @returns ConnInfo
                 */
                export const getConnInfo:
const getConnInfo: GetConnInfo
Get ConnInfo with Bun
@param c — Context  
@returns — ConnInfo GetConnInfo = 
(alias) type GetConnInfo = (c: Context) => ConnInfo
import GetConnInfo
Helper type(c:
(parameter) c: Context<any, any, {}>
Context
@param c — Context Context) => {          
(alias) class Context<E extends Env = any, P extends string = any, I extends Input = {}>
import Context
                  const server =
const server: BunServer | undefined getBunServer
(alias) getBunServer(c: Context): BunServer | undefined
import getBunServer
Get Bun Server Object from Context
@param c — Context  
@returns — Bun Server(c)          
(parameter) c: Context<any, any, {}>
Context
@param c — Context
                
                  if (!server) {          
const server: BunServer | undefined
                    throw new TypeError('env has to include the 2nd argument of fetch.')          
var TypeError: TypeErrorConstructor
new (message?: string, options?: ErrorOptions) => TypeError (+3 overloads)
                  }
                  if (typeof server
const server: BunServer.requestIP !== 'function') {          
(property) BunServer.requestIP?: ((req: Request) => {
    address: string;
    family: string;
    port: number;
}) | undefined
                    throw new TypeError('server.requestIP is not a function.')          
var TypeError: TypeErrorConstructor
new (message?: string, options?: ErrorOptions) => TypeError (+3 overloads)
                  }
                  const info =
const info: {
    address: string;
    family: string;
    port: number;
} server
const server: BunServer.requestIP
(property) BunServer.requestIP?: (req: Request) => {
    address: string;
    family: string;
    port: number;
}(c
(parameter) c: Context<any, any, {}>
Context
@param c — Context.req
(property) Context<any, any, {}>.req: HonoRequest<any, unknown>
.req is the instance of HonoRequest..raw)          
(property) HonoRequest<P extends string = "/", I extends Input["out"] = {}>.raw: Request
.raw can get the raw Request object.
@see — https://hono.dev/docs/api/request#raw  
@example

ts
// For Cloudflare Workers
app.post('/', async (c) => {
  const metadata = c.req.raw.cf?.hostMetadata?
  ...
})
                
                  return {
                    remote: {          
(property) ConnInfo.remote: NetAddrInfo
Remote information
                      address:
(property) address: string info
const info: {
    address: string;
    family: string;
    port: number;
}.address,          
(property) address: string
                      addressType:
(property) addressType: "IPv6" | "IPv4" | undefined info
const info: {
    address: string;
    family: string;
    port: number;
}.family === 'IPv6' ||
(property) family: string info
const info: {
    address: string;
    family: string;
    port: number;
}.family === 'IPv4' ?
(property) family: string info
const info: {
    address: string;
    family: string;
    port: number;
}.family : undefined,          
(property) family: "IPv6" | "IPv4"
                      port:
(property) port?: number | undefined
Transport port number info
const info: {
    address: string;
    family: string;
    port: number;
}.port,          
(property) port: number
                    },
                  }
                }