@stone-js/aws-lambda-http-adapter 0.3.1 → 0.8.0

package/dist/AWSLambdaHttpAdapter.d.ts

@@ -0,0 +1,85 @@
+import { RawHttpResponse, AwsLambdaContext, AwsLambdaHttpEvent, AwsLambdaHttpAdapterContext, AwsLambdaEventHandlerFunction } from './declarations';
+import { Adapter, IBlueprint } from '@stone-js/core';
+import { IncomingHttpEvent, IncomingHttpEventOptions, OutgoingHttpResponse } from '@stone-js/http-core';
+/**
+ * AWS Lambda HTTP Adapter for Stone.js.
+ *
+ * The `AwsLambdaHttpAdapter` extends the functionality of the Stone.js `Adapter`
+ * to provide seamless integration with AWS Lambda for HTTP-based events. This adapter
+ * transforms incoming HTTP events from AWS Lambda into `IncomingHttpEvent` instances
+ * and produces a `RawHttpResponse` as output.
+ *
+ * This adapter simplifies the process of handling HTTP events within AWS Lambda
+ * while adhering to the Stone.js framework's event-driven architecture.
+ *
+ * @template AwsLambdaHttpEvent - The type of the raw HTTP event from AWS Lambda.
+ * @template RawHttpResponse - The type of the raw HTTP response to send back.
+ * @template AwsLambdaContext - The AWS Lambda execution context type.
+ * @template IncomingHttpEvent - The type of the processed incoming HTTP event.
+ * @template IncomingHttpEventOptions - Options used to create an incoming HTTP event.
+ * @template OutgoingHttpResponse - The type of the outgoing HTTP response after processing.
+ * @template AwsLambdaHttpAdapterContext - Context type specific to the HTTP adapter.
+ *
+ * @extends Adapter
+ *
+ * @example
+ * ```typescript
+ * import { AwsLambdaHttpAdapter } from '@stone-js/aws-lambda-http-adapter';
+ *
+ * const adapter = AwsLambdaHttpAdapter.create({...});
+ *
+ * const handler = await adapter.run();
+ *
+ * export { handler };
+ * ```
+ *
+ * @see {@link https://stone-js.com/docs Stone.js Documentation}
+ * @see {@link https://docs.aws.amazon.com/lambda/latest/dg/ AWS Lambda Documentation}
+ */
+export declare class AwsLambdaHttpAdapter extends Adapter<AwsLambdaHttpEvent, RawHttpResponse, AwsLambdaContext, IncomingHttpEvent, IncomingHttpEventOptions, OutgoingHttpResponse, AwsLambdaHttpAdapterContext> {
+    /**
+     * Creates an instance of the `AwsLambdaHttpAdapter`.
+     *
+     * @param blueprint - The application blueprint.
+     * @returns A new instance of `AwsLambdaHttpAdapter`.
+     *
+     * @example
+     * ```typescript
+     * const adapter = AwsLambdaHttpAdapter.create(blueprint);
+     * await adapter.run();
+     * ```
+     */
+    static create(blueprint: IBlueprint): AwsLambdaHttpAdapter;
+    /**
+     * Executes the adapter and provides an AWS Lambda-compatible HTTP handler function.
+     *
+     * This method initializes the adapter and returns a handler function that can
+     * process HTTP events in AWS Lambda. It transforms raw events into `IncomingHttpEvent`
+     * instances and produces `RawHttpResponse` objects as output.
+     *
+     * @template ExecutionResultType - The type representing the AWS Lambda event handler function.
+     * @returns A promise resolving to the AWS Lambda HTTP handler function.
+     * @throws {AwsLambdaHttpAdapterError} If used outside the AWS Lambda environment.
+     */
+    run<ExecutionResultType = AwsLambdaEventHandlerFunction<RawHttpResponse>>(): Promise<ExecutionResultType>;
+    /**
+     * Initializes the adapter and validates its execution context.
+     *
+     * Ensures that the adapter is running in an AWS Lambda environment. Throws an error
+     * if it detects that the adapter is being used in an unsupported environment (e.g., a browser).
+     *
+     * @throws {AwsLambdaHttpAdapterError} If executed outside an AWS Lambda environment.
+     */
+    protected onStart(): Promise<void>;
+    /**
+     * Processes an incoming AWS Lambda HTTP event.
+     *
+     * Converts a raw AWS Lambda HTTP event into an `IncomingHttpEvent`, processes it through
+     * the Stone.js pipeline, and generates a `RawHttpResponse` to send back.
+     *
+     * @param rawEvent - The raw HTTP event received from AWS Lambda.
+     * @param executionContext - The AWS Lambda execution context associated with the event.
+     * @returns A promise resolving to the processed `RawHttpResponse`.
+     */
+    protected eventListener(rawEvent: AwsLambdaHttpEvent, executionContext: AwsLambdaContext): Promise<RawHttpResponse>;
+}

package/dist/AwsLambdaHttpErrorHandler.d.ts

@@ -0,0 +1,28 @@
+import { IBlueprint, AdapterErrorContext, IAdapterErrorHandler, AdapterEventBuilderType } from '@stone-js/core';
+import { AwsLambdaContext, AwsLambdaHttpEvent, RawHttpResponse } from './declarations';
+/**
+ * AwsLambdaHttpErrorHandler options.
+ */
+export interface AwsLambdaHttpErrorHandlerOptions {
+    blueprint: IBlueprint;
+}
+/**
+ * Class representing an AwsLambdaHttpErrorHandler.
+ */
+export declare class AwsLambdaHttpErrorHandler implements IAdapterErrorHandler<AwsLambdaHttpEvent, RawHttpResponse, AwsLambdaContext> {
+    private readonly logger;
+    /**
+     * Create an NodeHttpErrorHandler.
+     *
+     * @param options - NodeHttpErrorHandler options.
+     */
+    constructor({ blueprint }: AwsLambdaHttpErrorHandlerOptions);
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response builder.
+     */
+    handle(error: Error, context: AdapterErrorContext<AwsLambdaHttpEvent, RawHttpResponse, AwsLambdaContext>): AdapterEventBuilderType<RawHttpResponse>;
+}

package/dist/RawHttpResponseWrapper.d.ts

@@ -0,0 +1,69 @@
+import { IRawResponseWrapper } from '@stone-js/core';
+import { RawHttpResponse, RawHttpResponseOptions } from './declarations';
+/**
+ * Wrapper for HTTP raw responses in AWS Lambda.
+ *
+ * The `RawHttpResponseWrapper` is responsible for constructing and returning
+ * a raw HTTP response that conforms to the expected structure for AWS Lambda.
+ * It implements the `IRawResponseWrapper` interface, ensuring compatibility
+ * with the Stone.js framework.
+ */
+export declare class RawHttpResponseWrapper implements IRawResponseWrapper<RawHttpResponse> {
+    private readonly options;
+    /**
+     * Factory method to create an instance of `RawHttpResponseWrapper`.
+     *
+     * This method accepts partial response options, allowing the user to configure
+     * only the required fields. It initializes the wrapper with these options.
+     *
+     * @param options - Partial options to configure the HTTP response.
+     * @returns A new instance of `RawHttpResponseWrapper`.
+     *
+     * @example
+     * ```typescript
+     * const responseWrapper = RawHttpResponseWrapper.create({
+     *   statusCode: 200,
+     *   body: { message: 'Success' },
+     *   headers: { 'Content-Type': 'application/json' }
+     * });
+     *
+     * const response = responseWrapper.respond();
+     * console.log(response); // { statusCode: 200, body: '{"message":"Success"}', headers: { 'Content-Type': 'application/json' } }
+     * ```
+     */
+    static create(options: Partial<RawHttpResponseOptions>): RawHttpResponseWrapper;
+    /**
+     * Constructs an instance of `RawHttpResponseWrapper`.
+     *
+     * This constructor is private and should not be called directly.
+     * Use the `create` method to initialize an instance.
+     *
+     * @param options - Partial options for configuring the HTTP response.
+     */
+    private constructor();
+    /**
+     * Constructs and returns the raw HTTP response.
+     *
+     * The `respond` method generates a `RawHttpResponse` object based on the
+     * provided options. If any required fields are missing, it assigns default values:
+     * - `statusCode`: Defaults to `500`.
+     *
+     * @returns A `RawHttpResponse` object.
+     *
+     * @example
+     * ```typescript
+     * const responseWrapper = RawHttpResponseWrapper.create({ body: 'Hello, world!', statusCode: 200 });
+     * const response = responseWrapper.respond();
+     * console.log(response); // { statusCode: 500, statusMessage: '', body: 'Hello, world!', headers: undefined }
+     * ```
+     */
+    respond(): RawHttpResponse;
+    /**
+     * Extract all `Set-Cookie` values from a Headers instance, tolerant of runtimes without
+     * `getSetCookie()`.
+     *
+     * @param headers - The response headers.
+     * @returns The raw `Set-Cookie` strings.
+     */
+    private extractSetCookies;
+}

package/dist/browser/decorators/AwsLambdaHttp.d.ts

@@ -0,0 +1,38 @@
+import { ClassType } from '@stone-js/core';
+import { AwsLambdaHttpAdapterAdapterConfig } from '../../options/AwsLambdaHttpAdapterBlueprint';
+/**
+ * Configuration options for the `AwsLambdaHttp` decorator.
+ * These options extend the default AWS Lambda HTTP adapter configuration.
+ */
+export interface AwsLambdaHttpOptions extends Partial<AwsLambdaHttpAdapterAdapterConfig> {
+}
+/**
+ * A Stone.js decorator that integrates the AWS Lambda HTTP Adapter with a class.
+ *
+ * This decorator modifies the class to seamlessly enable AWS Lambda HTTP as the
+ * execution environment for a Stone.js application. By applying this decorator,
+ * the class is automatically configured with the necessary blueprint for AWS Lambda HTTP.
+ *
+ * NB: This decorator is stubbed for browser environments compatibility and does not
+ * perform any actual functionality in the browser. It is intended for use in Node.js environments
+ * where the Node.js HTTP adapter is applicable.
+ *
+ * @template T - The type of the class being decorated. Defaults to `ClassType`.
+ * @param options - Optional configuration to customize the AWS Lambda HTTP Adapter.
+ *
+ * @returns A class decorator that applies the AWS Lambda HTTP adapter configuration.
+ *
+ * @example
+ * ```typescript
+ * import { AwsLambdaHttp } from '@stone-js/aws-lambda-http-adapter';
+ *
+ * @AwsLambdaHttp({
+ *   alias: 'MyAwsLambdaHttpAdapter',
+ *   current: true,
+ * })
+ * class App {
+ *   // Your application logic here
+ * }
+ * ```
+ */
+export declare const AwsLambdaHttp: <T extends ClassType = ClassType>(_options?: AwsLambdaHttpOptions) => ClassDecorator;

package/dist/browser/options/NodeHttpAdapterBlueprint.d.ts

@@ -0,0 +1,13 @@
+import { AwsLambdaHttpAdapterBlueprint } from '../../options/AwsLambdaHttpAdapterBlueprint';
+/**
+ * Default blueprint configuration for the AWS Lambda Http Adapter.
+ *
+ * This blueprint defines the initial configuration for the AWS Lambda Http adapter
+ * within the Stone.js framework. It includes:
+ * - An alias for the AWS Lambda platform (`AWS_LAMBDA_HTTP_PLATFORM`).
+ * - A default resolver function (currently a placeholder).
+ * - Middleware, hooks, and state flags (`current`, `default`, `preferred`).
+ *
+ * NB: This is a stub for browser environments and does not perform any actual functionality in the browser.
+ */
+export declare const awsLambdaHttpAdapterBlueprint: AwsLambdaHttpAdapterBlueprint;

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A constant representing the AWS Lambda HTTP platform identifier.
+ *
+ * This constant is used as an alias for the AWS Lambda HTTP Adapter within the Stone.js framework.
+ * It helps in identifying and configuring platform-specific adapters or components for handling
+ * HTTP requests and responses.
+ */
+export declare const AWS_LAMBDA_HTTP_PLATFORM = "aws_lambda_http";

package/dist/declarations.d.ts

@@ -0,0 +1,124 @@
+import { RawHttpResponseWrapper } from './RawHttpResponseWrapper';
+import { AdapterContext, IAdapterEventBuilder, RawResponseOptions } from '@stone-js/core';
+import { IncomingHttpEvent, IncomingHttpEventOptions, OutgoingHttpResponse } from '@stone-js/http-core';
+/**
+ * Represents a raw HTTP response, extending from `RawHttpResponseOptions`.
+ */
+export type RawHttpResponse = RawHttpResponseOptions;
+/**
+ * Represents the AWS Lambda execution context as a key-value pair.
+ */
+export type AwsLambdaContext = Record<string, unknown>;
+/**
+ * Represents an AWS Lambda event handler function.
+ *
+ * @template RawResponseType - The type of the response returned by the handler.
+ * @param rawEvent - The raw event received by the AWS Lambda function.
+ * @param context - The AWS Lambda execution context.
+ * @returns A promise resolving to the response of type `RawResponseType`.
+ */
+export type AwsLambdaEventHandlerFunction<RawResponseType = RawHttpResponse> = (rawEvent: AwsLambdaHttpEvent, context: AwsLambdaContext) => Promise<RawResponseType>;
+/**
+ * Represents the response builder for the AWS Lambda http Adapter.
+ */
+export type AwsLambdaHttpAdapterResponseBuilder = IAdapterEventBuilder<RawHttpResponseOptions, RawHttpResponseWrapper>;
+/**
+ * Represents the structure of an AWS Lambda HTTP event across every supported trigger:
+ * API Gateway REST (payload v1), API Gateway HTTP API and Lambda Function URLs (payload v2),
+ * and Application Load Balancer (ALB). Every field is optional because each trigger populates a
+ * different subset; use {@link normalizeHttpEvent} to reduce it to a canonical shape.
+ */
+export interface AwsLambdaHttpEvent extends Record<string, unknown> {
+    /** Payload format version, e.g. `'1.0'` (REST) or `'2.0'` (HTTP API / Function URL). */
+    version?: string;
+    /** The path of the HTTP request (v1/ALB). */
+    path?: string;
+    /** The body of the HTTP request. */
+    body?: unknown;
+    /** The encoding format of the body, such as `base64`. */
+    encoding?: string;
+    /** The raw path of the HTTP request (v2). */
+    rawPath?: string;
+    /** The raw query string, without leading `?` (v2). */
+    rawQueryString?: string;
+    /** Indicates whether the request body is base64-encoded. */
+    isBase64Encoded?: boolean;
+    /** The headers of the HTTP request as key-value pairs (may be null/absent on some triggers). */
+    headers?: Record<string, string> | null;
+    /** Multi-value headers (v1 / ALB with multi-value enabled). */
+    multiValueHeaders?: Record<string, string[]>;
+    /** Raw cookie strings (v2 / Function URLs). */
+    cookies?: string[];
+    /** The HTTP method of the request (v1/ALB). */
+    httpMethod?: string;
+    /** The single-value query string parameters. */
+    queryStringParameters?: Record<string, string> | null;
+    /** The multi-value query string parameters (v1 / ALB with multi-value enabled). */
+    multiValueQueryStringParameters?: Record<string, string[]>;
+    /** The request context, whose shape varies by trigger. */
+    requestContext?: {
+        elb?: unknown;
+        identity?: {
+            sourceIp?: string;
+        };
+        httpMethod?: string;
+        http?: {
+            path?: string;
+            method?: string;
+            sourceIp?: string;
+        };
+    };
+}
+/**
+ * Represents the context for the AWS Lambda HTTP Adapter.
+ *
+ * This interface extends `AdapterContext` and includes additional properties specific
+ * to HTTP events in AWS Lambda.
+ */
+export interface AwsLambdaHttpAdapterContext extends AdapterContext<AwsLambdaHttpEvent, RawHttpResponse, AwsLambdaContext, IncomingHttpEvent, IncomingHttpEventOptions, OutgoingHttpResponse> {
+    /**
+     * The raw HTTP response associated with the current context.
+     */
+    rawResponse: RawHttpResponse;
+}
+/**
+ * Represents options for configuring a raw HTTP response.
+ *
+ * Extends the `RawResponseOptions` interface to include additional properties
+ * for managing response content, headers, status codes, and streaming files.
+ */
+export interface RawHttpResponseOptions extends RawResponseOptions {
+    /**
+     * The body of the HTTP response. Can be of any type, including strings, objects, or buffers.
+     */
+    body?: unknown;
+    /**
+     * The HTTP status code of the response (e.g., `200`, `404`).
+     */
+    statusCode: number;
+    /**
+     * The status message accompanying the HTTP status code (e.g., `OK`, `Not Found`).
+     */
+    statusMessage?: string;
+    /**
+     * Headers to include in the HTTP response. May be a `Headers` instance (from http-core) or a
+     * plain record; the wrapper normalizes it and lifts out `Set-Cookie`.
+     */
+    headers?: Headers | Record<string, string>;
+    /**
+     * Multi-value response headers (used by API Gateway REST v1 / ALB to emit multiple `Set-Cookie`).
+     */
+    multiValueHeaders?: Record<string, string[]>;
+    /**
+     * Response cookies as raw `Set-Cookie` strings (used by API Gateway HTTP API v2 / Function URLs).
+     */
+    cookies?: string[];
+    /**
+     * The detected trigger family, used to choose the correct multi-cookie response shape.
+     */
+    version?: 'v1' | 'v2' | 'alb';
+    /**
+     * The encoding format of the response body, such as `base64`.
+     */
+    isBase64Encoded?: boolean;
+}

package/dist/decorators/AwsLambdaHttp.d.ts

@@ -0,0 +1,34 @@
+import { ClassType } from '@stone-js/core';
+import { AwsLambdaHttpAdapterAdapterConfig } from '../options/AwsLambdaHttpAdapterBlueprint';
+/**
+ * Configuration options for the `AwsLambdaHttp` decorator.
+ * These options extend the default AWS Lambda HTTP adapter configuration.
+ */
+export interface AwsLambdaHttpOptions extends Partial<AwsLambdaHttpAdapterAdapterConfig> {
+}
+/**
+ * A Stone.js decorator that integrates the AWS Lambda HTTP Adapter with a class.
+ *
+ * This decorator modifies the class to seamlessly enable AWS Lambda HTTP as the
+ * execution environment for a Stone.js application. By applying this decorator,
+ * the class is automatically configured with the necessary blueprint for AWS Lambda HTTP.
+ *
+ * @template T - The type of the class being decorated. Defaults to `ClassType`.
+ * @param options - Optional configuration to customize the AWS Lambda HTTP Adapter.
+ *
+ * @returns A class decorator that applies the AWS Lambda HTTP adapter configuration.
+ *
+ * @example
+ * ```typescript
+ * import { AwsLambdaHttp } from '@stone-js/aws-lambda-http-adapter';
+ *
+ * @AwsLambdaHttp({
+ *   alias: 'MyAwsLambdaHttpAdapter',
+ *   current: true,
+ * })
+ * class App {
+ *   // Your application logic here
+ * }
+ * ```
+ */
+export declare const AwsLambdaHttp: <T extends ClassType = ClassType>(options?: AwsLambdaHttpOptions) => ClassDecorator;

package/dist/errors/AwsLambdaHttpAdapterError.d.ts

@@ -0,0 +1,7 @@
+import { ErrorOptions, IntegrationError } from '@stone-js/core';
+/**
+ * Custom error for AWS Lambda adapter operations.
+ */
+export declare class AwsLambdaHttpAdapterError extends IntegrationError {
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/event-normalizer.d.ts

@@ -0,0 +1,110 @@
+import { AwsLambdaHttpEvent } from './declarations';
+/**
+ * Platform-agnostic normalization of the many AWS "HTTP" Lambda event shapes.
+ *
+ * A single Lambda function can be fronted by very different integrations, each with its own
+ * event schema: API Gateway REST (payload v1), API Gateway HTTP API and Lambda Function URLs
+ * (payload v2), and Application Load Balancer (ALB). This module reduces all of them to one
+ * canonical {@link NormalizedHttpEvent} so the rest of the adapter never branches on the trigger.
+ *
+ * References:
+ * - v1 (REST): `httpMethod`, `path`, `queryStringParameters` + `multiValueQueryStringParameters`,
+ *   `headers` + `multiValueHeaders`, cookies in the `Cookie` header, `requestContext.identity.sourceIp`.
+ * - v2 (HTTP API / Function URLs): `version:'2.0'`, `requestContext.http.{method,sourceIp,path}`,
+ *   `rawPath`, `rawQueryString`, `headers`, `cookies: string[]`.
+ * - ALB: `requestContext.elb`, `httpMethod`, `path`, either `queryStringParameters` or
+ *   `multiValueQueryStringParameters` (depending on the target group's multi-value setting).
+ */
+/**
+ * The detected AWS HTTP trigger family.
+ */
+export type AwsHttpEventVersion = 'v1' | 'v2' | 'alb';
+/**
+ * A canonical HTTP request derived from any AWS HTTP Lambda event.
+ */
+export interface NormalizedHttpEvent {
+    /** The detected trigger family. */
+    version: AwsHttpEventVersion;
+    /** The HTTP method (upper-case). */
+    method: string;
+    /** The request path (no query string). */
+    path: string;
+    /** The raw query string (without leading `?`), fidelity-preserving. */
+    rawQueryString: string;
+    /** Lower-cased headers; multi-value headers joined with `, `. */
+    headers: Record<string, string>;
+    /** Raw cookie strings (e.g. `['a=1', 'b=2']`). */
+    cookies: string[];
+    /** The best-effort client source IP. */
+    sourceIp: string;
+    /** Whether {@link body} is base64-encoded. */
+    isBase64Encoded: boolean;
+    /** The raw request body as delivered by AWS (string or undefined). */
+    body?: string;
+}
+/**
+ * Detect which AWS HTTP trigger produced the event.
+ *
+ * @param event - The raw Lambda event.
+ * @returns The trigger family.
+ */
+export declare function detectEventVersion(event: AwsLambdaHttpEvent): AwsHttpEventVersion;
+/**
+ * Normalize headers to lower-cased keys, merging single and multi-value headers.
+ *
+ * @param event - The raw Lambda event.
+ * @returns Lower-cased headers with multi-value entries joined by `, `.
+ */
+export declare function normalizeHeaders(event: AwsLambdaHttpEvent): Record<string, string>;
+/**
+ * Build the raw query string from whichever representation the trigger provides.
+ *
+ * v2 gives the fidelity-preserving `rawQueryString`. v1/ALB give an object (single value) and
+ * optionally `multiValueQueryStringParameters` (preferred, preserves repeated keys). Values are
+ * URL-encoded so repeated/array values survive.
+ *
+ * @param event - The raw Lambda event.
+ * @param version - The detected trigger family.
+ * @returns The raw query string (no leading `?`).
+ */
+export declare function buildRawQueryString(event: AwsLambdaHttpEvent, version: AwsHttpEventVersion): string;
+/**
+ * Collect the raw cookie strings, regardless of trigger.
+ *
+ * v2 delivers `event.cookies: string[]`. v1/ALB deliver a single `Cookie` header (already merged
+ * into {@link NormalizedHttpEvent.headers}).
+ *
+ * @param event - The raw Lambda event.
+ * @param headers - The normalized headers.
+ * @returns The raw cookie strings.
+ */
+export declare function collectCookies(event: AwsLambdaHttpEvent, headers: Record<string, string>): string[];
+/**
+ * Resolve the client source IP across triggers.
+ *
+ * @param event - The raw Lambda event.
+ * @param version - The detected trigger family.
+ * @param headers - The normalized headers.
+ * @returns The source IP (empty string if unknown).
+ */
+export declare function resolveSourceIp(event: AwsLambdaHttpEvent, version: AwsHttpEventVersion, headers: Record<string, string>): string;
+/**
+ * Normalize any AWS HTTP Lambda event into the canonical {@link NormalizedHttpEvent}.
+ *
+ * @param event - The raw Lambda event.
+ * @returns The normalized request.
+ */
+export declare function normalizeHttpEvent(event: AwsLambdaHttpEvent): NormalizedHttpEvent;
+/**
+ * Extract the raw request body exactly as received, decoding base64 to a Buffer when needed.
+ *
+ * This is what the adapter exposes as `metadata.rawBody`: the untouched payload the client sent,
+ * available to consumers even when no body-parsing middleware is installed. Binary payloads are
+ * returned as a `Buffer` (never a lossy UTF-8 round-trip); text payloads as a string. A
+ * non-string, non-base64 body (e.g. a pre-parsed object from a test/custom integration) is
+ * returned as-is.
+ *
+ * @param event - The raw Lambda event.
+ * @returns The raw body as a Buffer, string, the original value, or undefined.
+ */
+export declare function getRawBody(event: AwsLambdaHttpEvent): Buffer | string | unknown;