@creator.co/wapi 1.2.5 → 1.2.6

package/README.md

@@ -1,6 +1,217 @@
-# Creator.co API Wrapper
+# WAPI - Web Application Programming Interface
 
-TODOs:
-    - js-docs
-    - readme docs
-    - badges
+**WAPI** is a powerful API wrapper designed to streamline web application development. It offers opinionated abstractions, simplifying common web development tasks. At its core, WAPI revolves around the concept of **transactions**, which can be applied in diverse scenarios, including handling async events, managing message queues, running AWS Lambda functions, and creating hybrid HTTP servers that seamlessly blend serverless and container-based approaches.
+
+- ![npm](https://img.shields.io/npm/dy/@creator.co/wapi) ![npm](https://img.shields.io/npm/v/@creator.co/wapi) ![npm (tag)](https://img.shields.io/npm/v/@creator.co/wapi/latest) ![Libraries.io dependency status for latest release, scoped npm package](https://img.shields.io/librariesio/release/npm/@creator.co/wapi)
+- ![GitHub commit activity](http://badges.dev.creator.co/github/commit-activity/m/Creator-co/Wapi)
+- ![GitHub last commit](http://badges.dev.creator.co/github/last-commit/Creator-co/Wapi)
+
+## 📖 Table of Contents
+- [📖 Table of Contents](#-table-of-contents)
+- [📍 Overview](#-overview)
+- [📦 Features](#-features)
+- [⚙️ Modules](#modules)
+- [🚀 Getting Started](#-getting-started)
+    - [🔧 Installation](#-installation)
+    - [🤖 Running .](#-running-.)
+    - [🧪 Tests](#-tests)
+- [🤝 Contributing](#-contributing)
+
+---
+
+## 📍 Overview
+
+The project is a TypeScript application that provides a collection of modules for handling transactions, managing processes, routing requests, sending emails, performing cryptographic operations, managing configuration settings, constructing HTTP responses, and providing utility functions and route definitions. It also includes tools for logging messages, validating data, and working with JSON Web Tokens. The core functionalities of the project revolve around helping developers build robust web applications and simplify common development tasks, such as handling requests, managing processes, and ensuring secure communication. Its value proposition lies in providing a comprehensive set of reusable components and abstractions that streamline the development process and improve the overall stability and security of web applications.
+
+---
+
+## 📦 Features
+
+Opinionated Framework Wrapping: WAPI offers opinionated abstractions to simplify common web development tasks and guide developers towards best practices.
+
+Transaction-Based Architecture: The core concept of transactions simplifies request and response handling, ensuring reliability and consistency.
+
+Support for Async Events: WAPI excels at handling asynchronous events, making it ideal for managing background processes and event-driven workflows.
+
+Message Queue Integration: Seamlessly integrate WAPI with message queues, simplifying the creation of distributed systems and asynchronous message processing.
+
+AWS Lambda Functionality: Deploy your code as AWS Lambda functions with ease, providing scalability and flexibility for your applications.
+
+Hybrid HTTP Servers: Create hybrid HTTP servers that seamlessly combine serverless and container-based architectures, allowing deployment in various environments.
+
+Crypto Utilities: WAPI provides utility classes for cryptographic operations, including encryption and decryption using AWS KMS. Securely manage sensitive data with ease.
+
+Email Sending: The Mailer class simplifies sending emails using AWS SES. Send both raw and templated emails with customizable parameters, enhancing communication capabilities.
+
+## ⚙️ Modules
+
+<details closed><summary>Root</summary>
+
+| File                                                                  | Summary                                                                                                                                                                                                                                                                                                            |
+| ---                                                                   | ---                                                                                                                                                                                                                                                                                                                |
+| [.eslintrc.cjs](https://github.com/Creator-co/Wapi/blob/main/.eslintrc.cjs)   | The code defines the linting rules for a TypeScript project. It extends recommended configurations, adds TypeScript-specific rules, and enables Prettier formatting. It also sets rules for imports ordering and disables certain rules.                                                                           |
+| [index.ts](https://github.com/Creator-co/Wapi/blob/main/index.ts)             | This code provides modules for handling transactions, managing processes, processing events, routing requests, sending emails, performing cryptographic operations, handling JSON Web Tokens, managing configuration settings, constructing HTTP responses, and providing utility functions and route definitions. |
+| [.eslintignore](https://github.com/Creator-co/Wapi/blob/main/.eslintignore)   | The.eslintignore file specifies file and directory patterns to exclude from linting using ESLint. In this case, it excludes the node_modules directory and the dist directory from being checked for linting issues.                                                                                               |
+| [jest.config.ts](https://github.com/Creator-co/Wapi/blob/main/jest.config.ts) | This code is a Jest configuration file that sets up the testing environment for a TypeScript project. It includes options for generating code coverage reports in various formats, setting coverage thresholds, and configuring reporters for test results.                                                        |
+
+</details>
+
+<details closed><summary>Workflows</summary>
+
+| File                                                                                    | Summary                                                                                                                                                                                                                                        |
+| ---                                                                                     | ---                                                                                                                                                                                                                                            |
+| [npmpublish.yml](https://github.com/Creator-co/Wapi/blob/main/.github/workflows/npmpublish.yml) | This code is a GitHub workflow that runs when code is pushed to the "main" or "gabe/tweaks" branches. It uses a tool to publish an NPM package, using Node version 16.x.                                                                       |
+| [prs.yml](https://github.com/Creator-co/Wapi/blob/main/.github/workflows/prs.yml)               | This code sets up a GitHub workflow that runs checks on pull requests (PRs) targeting the'master' or'main' branches. It uses a predefined workflow template called'prs-check.yml' and inherits secrets. The specified Node.js version is 16.x. |
+
+</details>
+
+<details closed><summary>Src</summary>
+
+| File                                                              | Summary                                                                                                                                                                                                              |
+| ---                                                               | ---                                                                                                                                                                                                                  |
+| [Globals.ts](https://github.com/Creator-co/Wapi/blob/main/src/Globals.ts) | The code in Globals.ts contains global constants and configurations for the application. It includes error messages, error codes, default values for HTTP listeners, and response messages and codes for exceptions. |
+
+</details>
+
+<details closed><summary>Crypto</summary>
+
+| File                                                                   | Summary                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---                                                                    | ---                                                                                                                                                                                                                                                                                                                                                                                          |
+| [JWT.ts](https://github.com/Creator-co/Wapi/blob/main/src/Crypto/JWT.ts)       | The code in JWT.ts provides functionalities to create and validate JSON Web Tokens (JWTs). It includes methods to generate a JWT given data and options, as well as to validate a JWT and return a response indicating its validity. The class has a constructor that sets the token secret and default expiration time. Overall, the code enables secure token generation and verification. |
+| [Crypto.ts](https://github.com/Creator-co/Wapi/blob/main/src/Crypto/Crypto.ts) | The Crypto class provides encryption and decryption functionality using AWS KMS. It encrypts data using RSAES_OAEP_SHA_256 encryption algorithm and decrypts data using the same algorithm. The class requires an AWS region and a KMS key ID to perform encryption and decryption operations.                                                                                               |
+
+</details>
+
+<details closed><summary>Logger</summary>
+
+| File                                                                   | Summary                                                                                                                                                                                                                                                                                                                                                                                      |
+| ---                                                                    | ---                                                                                                                                                                                                                                                                                                                                                                                          |
+| [Logger.ts](https://github.com/Creator-co/Wapi/blob/main/src/Logger/Logger.ts) | The Logger class is used for logging messages with different log levels. It provides functions for logging debug, info, warning, and error messages. The class can be configured with a log level and sensitive filtering keywords. It also has a blacklist of sensitive strings that can be excluded from logs. The logger formats the log messages and logs them using the console object. |
+
+</details>
+
+<details closed><summary>Config</summary>
+
+| File                                                                                   | Summary                                                                                                                                                                                                                                                                                                                                      |
+| ---                                                                                    | ---                                                                                                                                                                                                                                                                                                                                          |
+| [EnvironmentVar.ts](https://github.com/Creator-co/Wapi/blob/main/src/Config/EnvironmentVar.ts) | The code defines a class called EnvironmentVar that represents an environment variable. It has methods to resolve the value of the variable based on the environment type (local, plain remote, secure remote). It uses AWS SDK clients to retrieve the values from AWS SSM and Secrets Manager.                                             |
+| [Configuration.ts](https://github.com/Creator-co/Wapi/blob/main/src/Config/Configuration.ts)   | The code in the Configuration.ts file defines a Configuration class that allows retrieving values from environment variables or cache. It utilizes a schema to determine the properties to retrieve and their attributes. The class supports both synchronous and asynchronous retrieval of values, and also provides caching functionality. |
+
+</details>
+
+<details closed><summary>Publisher</summary>
+
+| File                                                                            | Summary                                                                                                                                                                                      |
+| ---                                                                             | ---                                                                                                                                                                                          |
+| [Publisher.ts](https://github.com/Creator-co/Wapi/blob/main/src/Publisher/Publisher.ts) | This code defines a Publisher class that can publish messages to an SNS topic. It establishes a connection to the SNS client and provides a method to publish messages on a specified topic. |
+
+</details>
+
+<details closed><summary>Server</summary>
+
+| File                                                                                 | Summary                                                                                                                                                                                                                                                                                                                                                                     |
+| ---                                                                                  | ---                                                                                                                                                                                                                                                                                                                                                                         |
+| [Router.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/Router.ts)               | The code is defining a Router class that handles routing logic for a web application. It includes functionalities such as configuring routes, listening on a port, setting a timeout, enabling CORS, and implementing a health check endpoint. The router can be used to handle different types of transactions and execute corresponding handlers.                         |
+| [RouteResolver.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/RouteResolver.ts) | The code implements a RouteResolver class that resolves routes based on provided configurations. It builds a routing system using a Routes class to add and resolve routes. The resolveRoute method takes an HTTP method and path and returns the resolved route, or undefined if not found. The buildRoutes method constructs the routes based on the given configuration. |
+
+</details>
+
+<details closed><summary>Lib</summary>
+
+| File                                                                                         | Summary                                                                                                                                                                                                                                                                                                                |
+| ---                                                                                          | ---                                                                                                                                                                                                                                                                                                                    |
+| [ContainerServer.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/ContainerServer.ts) | The ContainerServer class extends the Server class and handles serverless events. It utilizes a Proxy object for handling requests and responses. The class has methods for starting and stopping the server, as well as handling process events. The getExport method returns a callable function for exporting data. |
+| [Server.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/Server.ts)                   | The Server class handles serverless events by executing transactions and resolving routes based on the event. It validates input, parses path parameters, and calls the appropriate route handler.                                                                                                                     |
+
+</details>
+
+<details closed><summary>Container</summary>
+
+| File                                                                                                           | Summary                                                                                                                                                                                                                                                                                                                               |
+| ---                                                                                                            | ---                                                                                                                                                                                                                                                                                                                                   |
+| [HealthHandler.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/container/HealthHandler.ts)             | The code in HealthHandler.ts defines a function that handles a request and sends a response with the message'Healthy!'. It takes in a request object and a response object, and returns nothing.                                                                                                                                      |
+| [GenericHandler.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/container/GenericHandler.ts)           | This code defines a function that handles HTTP requests by invoking a serverless function and processing the response. It also includes a helper function to translate the serverless response to HTTP and send it back to the client.                                                                                                |
+| [Utils.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/container/Utils.ts)                             | The code provides two functions for parsing query string parameters from a given URL.-`parseMultiValueQueryStringParameters` parses multi-value query parameters into an object, allowing multiple values for the same key.-`parseQueryStringParameters` parses query parameters into an object, without support for multiple values. |
+| [GenericHandlerEvent.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/container/GenericHandlerEvent.ts) | The code is a TypeScript class that represents a generic handler event for serverless functions. It builds an APIGatewayProxyEvent object based on an HTTP request and provides methods to invoke the serverless handler function and build the context object for an AWS Lambda function.                                            |
+| [Proxy.ts](https://github.com/Creator-co/Wapi/blob/main/src/Server/lib/container/Proxy.ts)                             | The code defines a Proxy class that handles routing and server functionality. It creates an Express application, sets up middleware, starts listeners, and installs routes. It also provides methods to load, unload, and stop the listeners.                                                                                         |
+
+</details>
+
+<details closed><summary>Mailer</summary>
+
+| File                                                                   | Summary                                                                                                                                                                                                                                                                                      |
+| ---                                                                    | ---                                                                                                                                                                                                                                                                                          |
+| [Mailer.ts](https://github.com/Creator-co/Wapi/blob/main/src/Mailer/Mailer.ts) | The Mailer class is responsible for sending emails using AWS SES. It provides functions to send raw emails and templated emails with customizable parameters. It also includes methods for creating a new SMTP transporter and choosing the appropriate template based on the provided data. |
+
+</details>
+
+<details closed><summary>Api</summary>
+
+| File                                                                    | Summary                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---                                                                     | ---                                                                                                                                                                                                                                                                                                                                                                                                             |
+| [Utils.ts](https://github.com/Creator-co/Wapi/blob/main/src/API/Utils.ts)       | The Utils class contains various static methods for common operations. It includes functions to check if the application is running in a hybridless container, validate strings, parse strings into integers, parse JSON strings, validate numbers, and retrieve values from objects using case-insensitive key lookup.                                                                                         |
+| [Response.ts](https://github.com/Creator-co/Wapi/blob/main/src/API/Response.ts) | The code in the Response.ts file defines a class called Response, which represents an API response. It provides methods for manipulating and building the response, including handling errors, setting headers, and streaming the response. It also includes static methods for creating different types of API responses, such as success, error, redirect, and streaming responses.                           |
+| [Request.ts](https://github.com/Creator-co/Wapi/blob/main/src/API/Request.ts)   | The code defines a class called Request that provides utility methods for accessing request information in an API Gateway event. It can retrieve query parameters, headers, path parameters, request body, HTTP method, and other request details. It also allows setting fixed path parameters. This class is designed to facilitate handling and processing of incoming requests in a serverless environment. |
+
+</details>
+
+<details closed><summary>Baseevent</summary>
+
+| File                                                                                      | Summary                                                                                                                                                                                                                                                                                                                                              |
+| ---                                                                                       | ---                                                                                                                                                                                                                                                                                                                                                  |
+| [Process.ts](https://github.com/Creator-co/Wapi/blob/main/src/BaseEvent/Process.ts)                | The Process class provides functionality to create and manage processes. It allows executing shell commands in a child process, streaming the output, and capturing the exit code. This class is useful for managing and monitoring external processes or running background tasks. |
+| [ExecutionResult.ts](https://github.com/Creator-co/Wapi/blob/main/src/BaseEvent/ExecutionResult.ts) | The ExecutionResult class represents the result of executing a process. It includes information such as the command that was executed, the exit code, and the standard output and error streams. This class is used for capturing and reporting the results of process execution.                        |
+| [Transaction.ts](https://github.com/Creator-co/Wapi/blob/main/src/BaseEvent/Transaction.ts)        | The Transaction class is a central part of WAPI. It encapsulates the core concept of transactions, allowing developers to handle complex sequences of events and actions. A transaction represents a unit of work that can include multiple steps, such as database queries, HTTP requests, and more.          |
+| [Executor.ts](https://github.com/Creator-co/Wapi/blob/main/src/BaseEvent/Executor.ts)              | The Executor class is responsible for executing a series of steps in a transaction. It manages the transaction's state, ensures that steps are executed in the correct order, and handles error recovery. This class plays a key role in orchestrating the execution of transactions.                 |
+| [Events.ts](https://github.com/Creator-co/Wapi/blob/main/src/BaseEvent/Events.ts)                  | The Events class defines a set of event types that can be used within transactions. Events can be triggered, caught, and processed in various ways to implement business logic. This class provides a clear structure for managing events and actions within transactions.                            |
+
+</details>
+
+## 🚀 Getting Started
+
+To get started with the **WAPI** project, follow these steps:
+
+### 🔧 Installation
+
+Install Dependencies: Navigate to the project's root directory and install the required dependencies.
+
+```
+cd your-repo-name
+npm install
+```
+
+Set Up Configuration: Configure your environment by setting the necessary environment variables or AWS credentials, as required by the project.
+
+Build the Project: Build the project using TypeScript.
+
+```
+npm run build
+```
+
+### 🤖 Running the Project
+
+Run the Project Locally: You can run the project locally using the following command:
+
+```
+npm run start-local
+```
+
+This command starts the local development server.
+
+### 🧪 Tests
+
+Run Tests: The project includes a comprehensive set of tests. You can run the tests using:
+
+```
+npm test
+```
+
+Additionally, there are tests for running the project in a local environment:
+
+```
+npm run test-local
+```
+
+Congratulations! You now have WAPI up and running, and you're ready to start developing your web applications.
+
+If you have any more questions or need further assistance, please don't hesitate to ask.

package/dist/index.d.ts

@@ -8,4 +8,19 @@ import Crypto from './src/Crypto/Crypto';
 import JWT from './src/Crypto/JWT';
 import Mailer from './src/Mailer/Mailer';
 import Router, { Route } from './src/Server/Router';
+/**
+ * Exported modules:
+ * - Transaction: A module for handling transactions.
+ * - Process: A module for managing processes.
+ * - EventProcessor: A module for processing events.
+ * - Router: A module for routing requests.
+ * - Mailer: A module for sending emails.
+ * - Crypto: A module for cryptographic operations.
+ * - JWT: A module for handling JSON Web Tokens.
+ * - Configuration: A module for managing configuration settings.
+ * - Response: A module for constructing HTTP responses.
+ * - Utils: A module containing utility functions.
+ * - Route: A module for defining routes.
+ * - ResponseErrorType: An enumeration of possible response error types.
+ */
 export { Transaction, Process, EventProcessor, Router, Mailer, Crypto, JWT, Configuration, Response, Utils, Route, ResponseErrorType, };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,+CAAgE;AAuB9D,mBAvBK,kBAAQ,CAuBL;AAtBV,yCAAmC;AAwBjC,gBAxBK,eAAK,CAwBL;AAvBP,iEAA2D;AAazD,yBAbK,wBAAc,CAaL;AAZhB,mDAA6C;AAW3C,kBAXK,iBAAO,CAWL;AAVT,2DAAqD;AASnD,sBATK,qBAAW,CASL;AARb,4DAAsD;AAgBpD,wBAhBK,uBAAa,CAgBL;AAff,8CAAwC;AAatC,iBAbK,gBAAM,CAaL;AAZR,wCAAkC;AAahC,cAbK,aAAG,CAaL;AAZL,8CAAwC;AAUtC,iBAVK,gBAAM,CAUL;AATR,8CAAmD;AAOjD,iBAPK,gBAAM,CAOL"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,+CAAgE;AAsC9D,mBAtCK,kBAAQ,CAsCL;AArCV,yCAAmC;AAuCjC,gBAvCK,eAAK,CAuCL;AAtCP,iEAA2D;AA4BzD,yBA5BK,wBAAc,CA4BL;AA3BhB,mDAA6C;AA0B3C,kBA1BK,iBAAO,CA0BL;AAzBT,2DAAqD;AAwBnD,sBAxBK,qBAAW,CAwBL;AAvBb,4DAAsD;AA+BpD,wBA/BK,uBAAa,CA+BL;AA9Bf,8CAAwC;AA4BtC,iBA5BK,gBAAM,CA4BL;AA3BR,wCAAkC;AA4BhC,cA5BK,aAAG,CA4BL;AA3BL,8CAAwC;AAyBtC,iBAzBK,gBAAM,CAyBL;AAxBR,8CAAmD;AAsBjD,iBAtBK,gBAAM,CAsBL"}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@creator.co/wapi",
-    "version": "1.2.5",
+    "version": "1.2.6",
     "description": "",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -37,19 +37,24 @@
         "node-cache": "^5.1.2",
         "object-hash": "^3.0.0",
         "parse-duration": "^1.1.0",
+        "path-to-regexp": "^6.2.1",
         "pg": "^8.11.3",
         "sha1": "^1.1.1",
         "stack-trace": "0.0.10",
         "zod": "^3.22.4"
     },
     "devDependencies": {
+        "@jest/globals": "^29.7.0",
         "@types/aws-lambda": "^8.10.119",
         "@types/chai": "^4.3.9",
+        "@types/cors": "^2.8.15",
         "@types/express": "^4.17.19",
         "@types/jest": "^29.5.6",
         "@types/jsonwebtoken": "^9.0.3",
         "@types/node": "^20.5.7",
+        "@types/path-to-regexp": "^1.7.0",
         "@types/pg": "^8.10.5",
+        "@types/supertest": "^2.0.15",
         "@typescript-eslint/eslint-plugin": "^6.5.0",
         "@typescript-eslint/parser": "^6.5.0",
         "aws-lambda": "^1.0.7",

package/dist/src/API/Request.d.ts

@@ -1,140 +1,103 @@
 import type { Context, APIGatewayEvent } from 'aws-lambda';
 import Logger from '../Logger/Logger';
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Request
- * @typedef {Request}
- * @template InputType
+ * Represents a request object with utility methods for accessing request information.
+ * @template InputType - The type of the request body.
  */
 export default class Request<InputType> {
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
+     * Represents an API Gateway event for a request.
      * @type {APIGatewayEvent}
      */
     private requestEvent;
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
-     * @type {Context}
+     * The context object for the current instance.
      */
     private context;
     /**
-     * Creates an instance of Request.
-     *
-     * @constructor
-     * @param {APIGatewayEvent} requestEvent
-     * @param {Context} context
-     * @param {Logger} logger
+     * Constructs a new instance of the class.
+     * @param {APIGatewayEvent} requestEvent - The API Gateway event object.
+     * @param {Context} context - The context object.
+     * @param {Logger} logger - The logger object.
+     * @returns None
      */
     constructor(requestEvent: APIGatewayEvent, context: Context, logger: Logger);
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} paramName
-     * @returns {boolean}
+     * Checks if the given query parameter exists and has a valid value.
+     * @param {string} paramName - The name of the query parameter to check.
+     * @returns {boolean} - True if the query parameter exists and has a valid value, false otherwise.
      */
     containsQueryParam(paramName: string): boolean;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} paramName
-     * @returns {(string | null)}
+     * Retrieves the value of a query parameter from the request event's query string parameters.
+     * @param {string} paramName - The name of the query parameter to retrieve.
+     * @returns {string | null} The value of the query parameter, or null if it does not exist.
      */
     getQueryParam(paramName: string): string | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} headerName
-     * @returns {(string | null)}
+     * Retrieves the value of the specified header from the request event headers.
+     * @param {string} headerName - The name of the header to retrieve.
+     * @returns {string | null} - The value of the header, or null if the header is not found.
      */
     getHeader(headerName: string): string | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} cxtParam
-     * @returns {(any | null)}
+     * Retrieves the value of a context parameter from the request context object.
+     * @param {string} cxtParam - The name of the context parameter to retrieve.
+     * @returns The value of the context parameter, or null if it does not exist.
      */
     getContextParam(cxtParam: string): any | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} paramName
-     * @returns {boolean}
+     * Checks if the given parameter name exists in the path parameters and if its value is a valid string or number.
+     * @param {string} paramName - The name of the parameter to check.
+     * @returns {boolean} - True if the parameter exists and its value is a valid string or number, false otherwise.
      */
     containsPathParam(paramName: string): boolean;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {string} paramName
-     * @returns {(string | null)}
+     * Retrieves the value of a path parameter from the request event.
+     * @param {string} paramName - The name of the path parameter to retrieve.
+     * @returns {string | null} The value of the path parameter, or null if it does not exist.
      */
     getPathParam(paramName: string): string | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {InputType}
+     * Retrieves the body of the request event and parses it if it is a string.
+     * @returns {InputType} The parsed body of the request event.
      */
     getBody(): InputType;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {string}
+     * Retrieves the path from the request event.
+     * @returns {string} The path of the request event.
      */
     getPath(): string;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {string}
+     * Retrieves the HTTP method of the current request.
+     * @returns {string} The HTTP method of the request.
      */
     getMethod(): string;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {(object | null)}
+     * Retrieves the path parameters from the request event.
+     * @returns {object | null} - The path parameters object, or null if not found.
      */
     getPathParams(): object | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {(string | null)}
+     * Retrieves the value of the 'Authorization' header from the request.
+     * @returns The value of the 'Authorization' header, or null if it is not present.
      */
     getAuthorizationHeader(): string | null;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {string}
+     * Retrieves the request ID associated with the current execution context.
+     * @returns {string} The request ID.
      */
     getRequestID(): string;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @returns {string}
+     * Retrieves the origin IP address of the request.
+     * @returns {string} The origin IP address. If the IP address is not available, it returns 'unknown'.
      */
     getOriginIP(): string;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @param {any[]} keys
-     * @param {any[]} result
+     * Sets the fixed path parameters in the request event object.
+     * @param {any[]} keys - An array of keys representing the path parameter names.
+     * @param {any[]} result - An array of values representing the path parameter values.
+     * @returns None
      */
     setFixedPathParams(keys: any[], result: any[]): void;
 }