@h4ad/serverless-adapter 1.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,204 @@
+<h1 align="center">
+  🚀 Serverless Adapter
+</h1>
+
+<p align="center">
+  <a href="#install">Install</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#usage">Usage</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#support">Support</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#architecture">Architecture</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#credits">Credits</a>
+</p>
+
+[![npm package][npm-img]][npm-url]
+[![Build Status][build-img]][build-url]
+[![Downloads][downloads-img]][downloads-url]
+[![Issues][issues-img]][issues-url]
+[![Code Coverage][codecov-img]][codecov-url]
+[![Commitizen Friendly][commitizen-img]][commitizen-url]
+[![Semantic Release][semantic-release-img]][semantic-release-url]
+
+Run REST APIs and other web applications using your existing Node.js application framework (Express, Koa, Hapi and Fastify)
+, on top of AWS Lambda, Amazon API Gateway and many other event sources.
+
+This library was a refactored version of [@vendia/serverless-express](https://github.com/vendia/serverless-express), I created a new way to interact and extend event sources by creating contracts to abstract the integrations between each library layer.
+
+Why you would use this libray instead of [@vendia/serverless-express](https://github.com/vendia/serverless-express)?
+
+- Better APIs to extend library functionality.
+  - You don't need me to release a new version to integrate with the new event source, you can create an adapter and just call the `addAdapter` method when building your handler.
+- All code can be extended, if you want to modify the current behavior you can.
+  - This is important because if you find a bug, you can quickly resolve it by extending the class, _and then you can submit a PR to fix the bug_.
+- All code was written in Typescript.
+- We have >99% coverage.
+
+# Install
+
+Using NPM:
+
+```bash
+npm install --save @h4ad/serverless-adapter
+```
+
+Using Yarn:
+
+```bash
+yarn add @h4ad/serverless-adapter
+```
+
+# Usage
+
+You can quickly use this library as follows:
+
+```ts
+import app from './app';
+
+export const handler = ServerlessAdapter.new(app)
+  .setFramework(new ExpressFramework())
+  .setHandler(new DefaultHandler())
+  .setResolver(new PromiseResolver())
+  .addAdapter(new AlbAdapter())
+  .addAdapter(new SQSAdapter())
+  .addAdapter(new SNSAdapter())
+  .build();
+
+export { handler };
+```
+
+Too fast? Ok, I can explain.
+
+First, you need to create an instance of the builder with `ServerlessAdapter.new(app)`.
+The variable `app` is the instance of your framework (Express, Fastify, Koa, etc).
+
+So you need to specify for this library which `framework` you will use to handle the `request` with `setFramework`, you can only use one.
+If you use express in our backend, use [ExpressFramework](./src/frameworks/express.framework.ts), see more in [support](#support).
+
+Then you specify which `handler` you will use to interact with the serverless cloud with `setHandler`, currently we only have one, the [DefaultHandler](./src/handlers/default.handler.ts).
+In the next releases, maybe we will add support for Azure, Huawei and others, for now, you can use this default.
+
+Then you specify with `setResolver` which `resolver` you will use to wait for the library to forward the request to your `framework`, and then get the `response` back to your cloud.
+I recommend you use [PromiseResolver](./src/resolvers/promise.resolver.ts), it's the most cloud-agnostic `resolver`.
+
+By now, you've already added the basic abstractions of this library, now, you can add the `adapters` that will add support for receiving and processing different sources of `addAdapter` events.
+In the example I added [AlbAdapter](./src/adapters/aws/alb.adapter.ts), [SQSAdapter](./src/adapters/aws/sqs.adapter.ts) and [SNSAdapter](./src/adapters/aws/sns.adapter.ts).
+With these adapters you can connect your lambda to three different event sources and you can add more if you wish.
+
+Finally, we call `build` which will assemble your handler that you can expose directly to your cloud.
+
+Final thoughts:
+
+- You can set the `framework` only once.
+- You can set the `handler` only once.
+- You can set the `resolver` only once.
+- You can have as many `adapters` as you like, use and extend as you wish.
+
+# Support
+
+> We are in beta, so some adapters may not work as expected, feel free to create an issue or provide feedback on current behavior.
+
+By design we have these contracts that define the layers of the library: Frameworks, Adapters, Resolvers and Handlers.
+
+> If you don't know what each thing means, see [Architecture](#architecture).
+
+Currently, we support these frameworks:
+
+- [Express](https://expressjs.com/) by using ([ExpressFramework](./src/frameworks/express.framework.ts))
+- [Fastify](https://www.fastify.io/) by using ([FastifyFramework](./src/frameworks/fastify.framework.ts))
+- [Hapi](https://hapi.dev/) by using ([HapiFramework](./src/frameworks/hapi.framework.ts))
+- [Koa](https://koajs.com/) by using ([KoaFramework](./src/frameworks/koa.framework.ts))
+
+We support these event sources:
+
+- AWS
+  - [AWS Load Balancer](https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html) by
+    using ([AlbAdapter](./src/adapters/aws/alb.adapter.ts))
+  - [AWS Api Gateway V1](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html)
+    by using ([ApiGatewayV1Adapter](./src/adapters/aws/api-gateway-v1.adapter.ts))
+  - [AWS Api Gateway V2](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html)
+    by using ([ApiGatewayV2Adapter](./src/adapters/aws/api-gateway-v2.adapter.ts))
+  - [AWS DynamoDB](https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html) by
+    using ([DynamoDBAdapter](./src/adapters/aws/dynamodb.adapter.ts))
+  - [AWS Event Bridge / CloudWatch Events](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html)
+    by using ([EventBridgeAdapter](./src/adapters/aws/event-bridge.adapter.ts))
+  - [AWS Lambda Edge](https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html) by
+    using ([LambdaEdgeAdapter](./src/adapters/aws/lambda-edge.adapter.ts))
+  - [AWS SNS](https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sns.html) by
+    using ([SNSAdapter](./src/adapters/aws/sns.adapter.ts))
+  - [AWS SQS](https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sqs.html) by
+    using ([SQSAdapter](./src/adapters/aws/sqs.adapter.ts))
+- Azure
+  - The support is cooming soon.
+- Huawei
+  - The support is cooming soon.
+
+We support these resolvers:
+
+- Promise by using ([PromiseResolver](./src/resolvers/promise.resolver.ts))
+- Callback by using ([CallbackResolver](./src/resolvers/callback.resolver.ts))
+- AWS Context by using ([AwsContextResolver](./src/resolvers/aws-context.resolver.ts))
+
+We support these handlers:
+
+- Default by using ([DefaultHandler](./src/handlers/default.handler.ts))
+
+# Architecture
+
+The main purpose of this library is to allow the developer to add support for any cloud and as many event sources as he wants, without having to create an issue to request the feature or copy the library code because the library doesn't expose good APIs for you to extend its functionality
+
+So I refactored [@vendia/serverless-express](https://github.com/vendia/serverless-express) with 4 layers of abstraction: Framework, Handler, Resolver and Adapter.
+
+The [FrameworkContract](./src/contracts/framework.contract.ts) is responsible for forwarding to [IncomingMessage](https://nodejs.org/api/http.html#class-httpincomingmessage) and [ServerResponse](https://nodejs.org/api/http.html#class-httpserverresponse) for your application instance.
+With this abstraction you can implement any framework you want, they just need to accept both parameters and call [end](https://nodejs.org/api/http.html#class-httpserverresponse) in [ServerResponse](https://nodejs.org/api/http.html#class-httpserverresponse), so the library knows when to continue and return the response.
+
+The [HandlerContract](./src/contracts/handler.contract.ts) is responsible to get the input from the serverless and then manage to call each layer of abstraction to return a response.
+With this abstraction, you can implement different ways to receive input from your serverless environment.
+They usually have the same structure, but if you need to deal with a very different cloud, you can use this abstraction to add support for that cloud.
+
+> Handler is a good choice for implementing (~~monsters~~) ways to receive input.
+> For example, we can create an http server as its handler to test our serverless code without having to launch the framework. Because? I don't know, but you can.
+
+The [ResolverContract](./src/contracts/resolver.contract.ts) is responsible for waiting for the framework to handle the request and then returning the response to the cloud.
+Using AWS for example, you have three ways to wait for the response: returning a promise, calling the callback, and ~~using in-context methods~~, each option has its own benefits, but generally the promise option will be the better because any good cloud provider will support promises.
+
+Finally, the masterpiece of this library, the [AdapterContract](./src/contracts/adapter.contract.ts) is responsible for handling the received event, transforming the request in a way that your application can understand and then transforming the response in a way your cloud can understand.
+
+Well, with these four contracts, you'll be able to add support to any cloud that exists (no more excuses not to use cloud X with NodeJS).
+
+## Why you create this library?
+
+The real reason I created this library was because I wanted to add API Gateway and SQS support at the same time to save some money.
+But, [@vendia/serverless-express](https://github.com/vendia/serverless-express) was not supported, so I [created a PR](https://github.com/vendia/serverless-express/pull/483), but until I finished this library, that PR was never accepted.
+
+So I build my own library based on that library with better APIs so I never have to wait for the maintainer to accept my PR just to extend the library's functionality :)
+
+# Credits
+
+Honestly, I just refactored all the code that the @vendia team and many other contributors wrote, thanks so much to them for existing and giving us a brilliant library that is the core of my current company.
+
+[build-img]:https://github.com/H4ad/serverless-adapter/actions/workflows/release.yml/badge.svg
+
+[build-url]:https://github.com/H4ad/serverless-adapter/actions/workflows/release.yml
+
+[downloads-img]:https://img.shields.io/npm/dt/serverless-adapter
+
+[downloads-url]:https://www.npmtrends.com/serverless-adapter
+
+[npm-img]:https://img.shields.io/npm/v/serverless-adapter
+
+[npm-url]:https://www.npmjs.com/package/serverless-adapter
+
+[issues-img]:https://img.shields.io/github/issues/H4ad/serverless-adapter
+
+[issues-url]:https://github.com/H4ad/serverless-adapter/issues
+
+[codecov-img]:https://codecov.io/gh/H4ad/serverless-adapter/branch/main/graph/badge.svg
+
+[codecov-url]:https://codecov.io/gh/H4ad/serverless-adapter
+
+[semantic-release-img]:https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
+
+[semantic-release-url]:https://github.com/semantic-release/semantic-release
+
+[commitizen-img]:https://img.shields.io/badge/commitizen-friendly-brightgreen.svg
+
+[commitizen-url]:http://commitizen.github.io/cz-cli/

package/lib/@types/binary-settings.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The interface representing the settings for whether the response should be treated as binary or not
+ *
+ * @note Encoded as binary means the response body will be converted to base64
+ */
+export declare type BinarySettings = {
+    /**
+     * This property can be a function that receives the response headers and returns whether that response should be encoded as binary.
+     * Otherwise, you can specify not to treat any response as binary by putting `false` in this property.
+     *
+     * @note Setting this property prevents the `contentTypes` and `contentEncodings` properties from being used.
+     */
+    isBinary: ((headers: Record<string, string | string[] | undefined>) => boolean) | false;
+} | {
+    /**
+     * The list of content types that will be treated as binary
+     */
+    contentTypes: (string | RegExp)[];
+    /**
+     * The list of content encodings that will be treated as binary
+     */
+    contentEncodings: string[];
+};

package/lib/@types/binary-settings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/headers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The record that represents the headers that doesn't have multiple values in the value
+ *
+ * @example```typescript
+ * { 'Accept-Encoding': 'gzip, deflate, br' }
+ * ```
+ */
+export declare type SingleValueHeaders = Record<string, string | undefined>;
+/**
+ * The record that represents the headers that have multiple values in the value
+ *
+ * @example```typescript
+ * { 'Accept-Encoding': ['gzip', 'deflate', 'br'] }
+ * ```
+ */
+export declare type MultiValueHeaders = Record<string, string[] | undefined>;
+/**
+ * The record that represents the headers that can both single or multiple values in the value
+ *
+ * @example```typescript
+ * { 'Accept-Encoding': ['gzip', 'deflate', 'br'], 'Host': 'xyz.execute-api.us-east-1.amazonaws.com' }
+ * ```
+ */
+export declare type BothValueHeaders = Record<string, string | string[] | undefined>;

package/lib/@types/headers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Removes 'optional' attributes from a type's properties
+ */
+export declare type Concrete<Type> = {
+    [Property in keyof Type]-?: Type[Property];
+};

package/lib/@types/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './binary-settings';
+export * from './headers';
+export * from './proxy-params';

package/lib/@types/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-settings"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./proxy-params"), exports);

package/lib/@types/proxy-params.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { RequestListener } from 'http';
+import { BinarySettings } from './binary-settings';
+export interface ProxyParams {
+    app: RequestListener;
+    binaryMimeTypes?: string[];
+    binarySettings?: BinarySettings;
+}

package/lib/@types/proxy-params.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/aws/alb.adapter.d.ts

@@ -0,0 +1,58 @@
+import type { ALBEvent, ALBResult, Context } from 'aws-lambda';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The options to customize the {@link AlbAdapter}
+ */
+export interface AlbAdapterOptions {
+    /**
+     * Strip base path for custom domains
+     *
+     * @default ''
+     */
+    stripBasePath?: string;
+}
+/**
+ * The adapter to handle requests from AWS ALB
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new AlbAdapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html Event Reference}
+ */
+export declare class AlbAdapter implements AdapterContract<ALBEvent, Context, ALBResult> {
+    protected readonly options?: AlbAdapterOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link AlbAdapter}
+     */
+    constructor(options?: AlbAdapterOptions | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is ALBEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: ALBEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse({ event, headers: responseHeaders, body, isBase64Encoded, statusCode, }: GetResponseAdapterProps<ALBEvent>): ALBResult;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }: OnErrorProps<ALBEvent, ALBResult>): void;
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    protected getPathFromEvent(event: ALBEvent): string;
+}

package/lib/adapters/aws/alb.adapter.js

@@ -0,0 +1,119 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlbAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS ALB
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new AlbAdapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html Event Reference}
+ */
+class AlbAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link AlbAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return AlbAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const albEvent = event;
+        return !!((albEvent === null || albEvent === void 0 ? void 0 : albEvent.requestContext) && albEvent.requestContext.elb);
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        const method = event.httpMethod;
+        const path = this.getPathFromEvent(event);
+        const headers = event.multiValueHeaders
+            ? (0, core_1.getFlattenedHeadersMap)(event.multiValueHeaders, ',', true)
+            : event.headers;
+        let body;
+        if (event.body) {
+            const [bufferBody, contentLength] = (0, core_1.getEventBodyAsBuffer)(event.body, event.isBase64Encoded);
+            body = bufferBody;
+            headers['content-length'] = String(contentLength);
+        }
+        let remoteAddress = '';
+        // ref: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/x-forwarded-headers.html#x-forwarded-for
+        if (headers['x-forwarded-for'])
+            remoteAddress = headers['x-forwarded-for'];
+        return {
+            method,
+            headers,
+            body,
+            remoteAddress,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse({ event, headers: responseHeaders, body, isBase64Encoded, statusCode, }) {
+        const multiValueHeaders = !event.headers
+            ? (0, core_1.getMultiValueHeadersMap)(responseHeaders)
+            : undefined;
+        const headers = event.headers
+            ? (0, core_1.getFlattenedHeadersMap)(responseHeaders)
+            : undefined;
+        return {
+            statusCode,
+            body,
+            headers,
+            multiValueHeaders,
+            isBase64Encoded,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }) {
+        const body = respondWithErrors ? error.stack || '' : '';
+        const errorResponse = this.getResponse({
+            event,
+            statusCode: 500,
+            body,
+            headers: {},
+            isBase64Encoded: false,
+            log,
+        });
+        delegatedResolver.succeed(errorResponse);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    getPathFromEvent(event) {
+        var _a;
+        const stripBasePath = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.stripBasePath, '');
+        const replaceRegex = new RegExp(`^${stripBasePath}`);
+        const path = event.path.replace(replaceRegex, '');
+        const queryParams = event.headers
+            ? event.queryStringParameters
+            : event.multiValueQueryStringParameters;
+        return (0, core_1.getPathWithQueryStringParams)(path, queryParams || {});
+    }
+}
+exports.AlbAdapter = AlbAdapter;

package/lib/adapters/aws/api-gateway-v1.adapter.d.ts

@@ -0,0 +1,63 @@
+import type { APIGatewayProxyResult, Context } from 'aws-lambda';
+import type { APIGatewayProxyEvent } from 'aws-lambda/trigger/api-gateway-proxy';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The options to customize the {@link ApiGatewayV1Adapter}
+ */
+export interface ApiGatewayV1Options {
+    /**
+     * Strip base path for custom domains
+     *
+     * @default ''
+     */
+    stripBasePath?: string;
+}
+/**
+ * The adapter to handle requests from AWS Api Gateway V1
+ *
+ * As per {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html know issues}, we throw an exception when you send the `transfer-encoding=chunked`, currently, API Gateway doesn't support chunked transfer.
+ *
+ * @note This adapter is not fully compatible with @vendia/serverless-express, on @vendia they filter `transfer-encoding=chunked` but we throw an exception.
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayV1Adapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html Event Reference}
+ */
+export declare class ApiGatewayV1Adapter implements AdapterContract<APIGatewayProxyEvent, Context, APIGatewayProxyResult> {
+    protected readonly options?: ApiGatewayV1Options | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link ApiGatewayV1Adapter}
+     */
+    constructor(options?: ApiGatewayV1Options | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is APIGatewayProxyEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: APIGatewayProxyEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, response, }: GetResponseAdapterProps<APIGatewayProxyEvent>): APIGatewayProxyResult;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }: OnErrorProps<APIGatewayProxyEvent, APIGatewayProxyResult>): void;
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    protected getPathFromEvent(event: APIGatewayProxyEvent): string;
+}