@rio-cloud/cdk-v2-constructs 6.12.6 → 6.13.0

package/node_modules/@aws-lambda-powertools/commons/lib/esm/config/EnvironmentVariablesService.d.ts

@@ -0,0 +1,78 @@
+import type { ConfigServiceInterface } from '../types/ConfigServiceInterface.js';
+/**
+ * This class is used to fetch environment variables that are available in the execution environment.
+ *
+ * These variables can be a mix of runtime environment variables set by AWS and
+ * other environment variables that are set by the developer to configure Powertools for AWS Lambda.
+ *
+ * @example
+ * ```typescript
+ * import { EnvironmentVariablesService } from '@aws-lambda-powertools/commons/';
+ *
+ * const config = new EnvironmentVariablesService();
+ * const serviceName = config.getServiceName();
+ * ```
+ *
+ * @see https://docs.powertools.aws.dev/lambda/typescript/latest/#environment-variables
+ *
+ * @class
+ */
+declare class EnvironmentVariablesService implements ConfigServiceInterface {
+    /**
+     * Increase JSON indentation for Logger to ease debugging when running functions locally or in a non-production environment
+     */
+    protected devModeVariable: string;
+    /**
+     * Set service name used for tracing namespace, metrics dimension and structured logging
+     */
+    protected serviceNameVariable: string;
+    /**
+     * AWS X-Ray Trace ID environment variable
+     * @private
+     */
+    private xRayTraceIdVariable;
+    /**
+     * Get the value of an environment variable by name.
+     *
+     * @param {string} name The name of the environment variable to fetch.
+     */
+    get(name: string): string;
+    /**
+     * Get the value of the `POWERTOOLS_SERVICE_NAME` environment variable.
+     */
+    getServiceName(): string;
+    /**
+     * Get the value of the `_X_AMZN_TRACE_ID` environment variable.
+     *
+     * The AWS X-Ray Trace data available in the environment variable has this format:
+     * `Root=1-5759e988-bd862e3fe1be46a994272793;Parent=557abcec3ee5a047;Sampled=1`,
+     *
+     * The actual Trace ID is: `1-5759e988-bd862e3fe1be46a994272793`.
+     */
+    getXrayTraceId(): string | undefined;
+    /**
+     * Determine if the current invocation is part of a sampled X-Ray trace.
+     *
+     * The AWS X-Ray Trace data available in the environment variable has this format:
+     * `Root=1-5759e988-bd862e3fe1be46a994272793;Parent=557abcec3ee5a047;Sampled=1`,
+     */
+    getXrayTraceSampled(): boolean;
+    /**
+     * Determine if the current invocation is running in a development environment.
+     */
+    isDevMode(): boolean;
+    /**
+     * Helper function to determine if a value is considered thruthy.
+     *
+     * @param value The value to check for truthiness.
+     */
+    isValueTrue(value: string): boolean;
+    /**
+     * Get the AWS X-Ray Trace data from the environment variable.
+     *
+     * The method parses the environment variable `_X_AMZN_TRACE_ID` and returns an object with the key-value pairs.
+     */
+    private getXrayTraceData;
+}
+export { EnvironmentVariablesService };
+//# sourceMappingURL=EnvironmentVariablesService.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/config/EnvironmentVariablesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentVariablesService.d.ts","sourceRoot":"","sources":["../../../src/config/EnvironmentVariablesService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAEjF;;;;;;;;;;;;;;;;;GAiBG;AACH,cAAM,2BAA4B,YAAW,sBAAsB;IACjE;;OAEG;IACH,SAAS,CAAC,eAAe,SAAoB;IAC7C;;OAEG;IACH,SAAS,CAAC,mBAAmB,SAA6B;IAC1D;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAsB;IAEjD;;;;OAIG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIhC;;OAEG;IACI,cAAc,IAAI,MAAM;IAI/B;;;;;;;OAOG;IACI,cAAc,IAAI,MAAM,GAAG,SAAS;IAM3C;;;;;OAKG;IACI,mBAAmB,IAAI,OAAO;IAMrC;;OAEG;IACI,SAAS,IAAI,OAAO;IAI3B;;;;OAIG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAM1C;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAiBzB;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/config/EnvironmentVariablesService.js

@@ -0,0 +1,103 @@
+/**
+ * This class is used to fetch environment variables that are available in the execution environment.
+ *
+ * These variables can be a mix of runtime environment variables set by AWS and
+ * other environment variables that are set by the developer to configure Powertools for AWS Lambda.
+ *
+ * @example
+ * ```typescript
+ * import { EnvironmentVariablesService } from '@aws-lambda-powertools/commons/';
+ *
+ * const config = new EnvironmentVariablesService();
+ * const serviceName = config.getServiceName();
+ * ```
+ *
+ * @see https://docs.powertools.aws.dev/lambda/typescript/latest/#environment-variables
+ *
+ * @class
+ */
+class EnvironmentVariablesService {
+    /**
+     * Increase JSON indentation for Logger to ease debugging when running functions locally or in a non-production environment
+     */
+    devModeVariable = 'POWERTOOLS_DEV';
+    /**
+     * Set service name used for tracing namespace, metrics dimension and structured logging
+     */
+    serviceNameVariable = 'POWERTOOLS_SERVICE_NAME';
+    /**
+     * AWS X-Ray Trace ID environment variable
+     * @private
+     */
+    xRayTraceIdVariable = '_X_AMZN_TRACE_ID';
+    /**
+     * Get the value of an environment variable by name.
+     *
+     * @param {string} name The name of the environment variable to fetch.
+     */
+    get(name) {
+        return process.env[name]?.trim() || '';
+    }
+    /**
+     * Get the value of the `POWERTOOLS_SERVICE_NAME` environment variable.
+     */
+    getServiceName() {
+        return this.get(this.serviceNameVariable);
+    }
+    /**
+     * Get the value of the `_X_AMZN_TRACE_ID` environment variable.
+     *
+     * The AWS X-Ray Trace data available in the environment variable has this format:
+     * `Root=1-5759e988-bd862e3fe1be46a994272793;Parent=557abcec3ee5a047;Sampled=1`,
+     *
+     * The actual Trace ID is: `1-5759e988-bd862e3fe1be46a994272793`.
+     */
+    getXrayTraceId() {
+        const xRayTraceData = this.getXrayTraceData();
+        return xRayTraceData?.Root;
+    }
+    /**
+     * Determine if the current invocation is part of a sampled X-Ray trace.
+     *
+     * The AWS X-Ray Trace data available in the environment variable has this format:
+     * `Root=1-5759e988-bd862e3fe1be46a994272793;Parent=557abcec3ee5a047;Sampled=1`,
+     */
+    getXrayTraceSampled() {
+        const xRayTraceData = this.getXrayTraceData();
+        return xRayTraceData?.Sampled === '1';
+    }
+    /**
+     * Determine if the current invocation is running in a development environment.
+     */
+    isDevMode() {
+        return this.isValueTrue(this.get(this.devModeVariable));
+    }
+    /**
+     * Helper function to determine if a value is considered thruthy.
+     *
+     * @param value The value to check for truthiness.
+     */
+    isValueTrue(value) {
+        const truthyValues = ['1', 'y', 'yes', 't', 'true', 'on'];
+        return truthyValues.includes(value.toLowerCase());
+    }
+    /**
+     * Get the AWS X-Ray Trace data from the environment variable.
+     *
+     * The method parses the environment variable `_X_AMZN_TRACE_ID` and returns an object with the key-value pairs.
+     */
+    getXrayTraceData() {
+        const xRayTraceEnv = this.get(this.xRayTraceIdVariable);
+        if (xRayTraceEnv === '')
+            return undefined;
+        if (!xRayTraceEnv.includes('='))
+            return { Root: xRayTraceEnv };
+        const xRayTraceData = {};
+        for (const field of xRayTraceEnv.split(';')) {
+            const [key, value] = field.split('=');
+            xRayTraceData[key] = value;
+        }
+        return xRayTraceData;
+    }
+}
+export { EnvironmentVariablesService };

package/node_modules/@aws-lambda-powertools/commons/lib/esm/fromBase64.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Convert a base64 string to a Uint8Array.
+ *
+ * The input string must be a valid base64 string, otherwise an error will be thrown.
+ *
+ * The encoding parameter is optional and defaults to 'utf-8'.
+ *
+ * @example
+ * ```ts
+ * import { fromBase64 } from '@aws-lambda-powertools/commons/utils/base64';
+ *
+ * const encodedValue = 'aGVsbG8gd29ybGQ=';
+ *
+ * const decoded = fromBase64(encodedValue);
+ * // new Uint8Array([ 97, 71, 86, 115, 98, 71, 56, 103, 100, 50, 57, 121, 98, 71, 81, 61 ]);
+ * ```
+ *
+ * @param input The base64 string to convert to a Uint8Array
+ * @param encoding The encoding of the input string (optional)
+ */
+declare const fromBase64: (input: string, encoding?: BufferEncoding) => Uint8Array;
+export { fromBase64 };
+//# sourceMappingURL=fromBase64.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/fromBase64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromBase64.d.ts","sourceRoot":"","sources":["../../src/fromBase64.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,UAAU,UAAW,MAAM,aAAa,cAAc,KAAG,UAU9D,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/fromBase64.js

@@ -0,0 +1,32 @@
+const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+/**
+ * Convert a base64 string to a Uint8Array.
+ *
+ * The input string must be a valid base64 string, otherwise an error will be thrown.
+ *
+ * The encoding parameter is optional and defaults to 'utf-8'.
+ *
+ * @example
+ * ```ts
+ * import { fromBase64 } from '@aws-lambda-powertools/commons/utils/base64';
+ *
+ * const encodedValue = 'aGVsbG8gd29ybGQ=';
+ *
+ * const decoded = fromBase64(encodedValue);
+ * // new Uint8Array([ 97, 71, 86, 115, 98, 71, 56, 103, 100, 50, 57, 121, 98, 71, 81, 61 ]);
+ * ```
+ *
+ * @param input The base64 string to convert to a Uint8Array
+ * @param encoding The encoding of the input string (optional)
+ */
+const fromBase64 = (input, encoding) => {
+    if ((input.length * 3) % 4 !== 0) {
+        throw new TypeError('Incorrect padding on base64 string.');
+    }
+    if (!BASE64_REGEX.exec(input)) {
+        throw new TypeError('Invalid base64 string.');
+    }
+    const buffer = encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+export { fromBase64 };

package/node_modules/@aws-lambda-powertools/commons/lib/esm/index.d.ts

@@ -0,0 +1,8 @@
+export { isRecord, isString, isNumber, isIntegerNumber, isTruthy, isNull, isNullOrUndefined, getType, isStrictEqual, } from './typeUtils.js';
+export { Utility } from './Utility.js';
+export { EnvironmentVariablesService } from './config/EnvironmentVariablesService.js';
+export { addUserAgentMiddleware, isSdkClient } from './awsSdkUtils.js';
+export { cleanupMiddlewares } from './middleware/cleanupMiddlewares.js';
+export { TRACER_KEY, LOGGER_KEY, METRICS_KEY, IDEMPOTENCY_KEY, } from './middleware/constants.js';
+export { PT_VERSION } from './version.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,MAAM,EACN,iBAAiB,EACjB,OAAO,EACP,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AACtF,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EACL,UAAU,EACV,UAAU,EACV,WAAW,EACX,eAAe,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/index.js

@@ -0,0 +1,7 @@
+export { isRecord, isString, isNumber, isIntegerNumber, isTruthy, isNull, isNullOrUndefined, getType, isStrictEqual, } from './typeUtils.js';
+export { Utility } from './Utility.js';
+export { EnvironmentVariablesService } from './config/EnvironmentVariablesService.js';
+export { addUserAgentMiddleware, isSdkClient } from './awsSdkUtils.js';
+export { cleanupMiddlewares } from './middleware/cleanupMiddlewares.js';
+export { TRACER_KEY, LOGGER_KEY, METRICS_KEY, IDEMPOTENCY_KEY, } from './middleware/constants.js';
+export { PT_VERSION } from './version.js';

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/cleanupMiddlewares.d.ts

@@ -0,0 +1,49 @@
+import type { MiddyLikeRequest } from '../types/middy.js';
+/**
+ * Function used to cleanup Powertools for AWS resources when a Middy
+ * middleware [returns early](https://middy.js.org/docs/intro/early-interrupt)
+ * and terminates the middleware chain.
+ *
+ * When a middleware returns early, all the middleware lifecycle functions
+ * that come after it are not executed. This means that if a middleware
+ * was relying on certain logic to be run during the `after` or `onError`
+ * lifecycle functions, that logic will not be executed.
+ *
+ * This is the case for the middlewares that are part of Powertools for AWS
+ * which rely on these lifecycle functions to perform cleanup operations
+ * like closing the current segment in the tracer or flushing any stored
+ * metrics.
+ *
+ * When authoring a middleware that might return early, you can use this
+ * function to cleanup Powertools resources. This function will check if
+ * any cleanup function is present in the `request.internal` object and
+ * execute it.
+ *
+ * @example
+ * ```typescript
+ * import middy from '@middy/core';
+ * import { cleanupMiddlewares } from '@aws-lambda-powertools/commons/lib/middleware';
+ *
+ * // Example middleware that returns early
+ * const myCustomMiddleware = (): middy.MiddlewareObj => {
+ *   const before = async (request: middy.Request): Promise<undefined | string> => {
+ *     // If the request is a GET, return early (as an example)
+ *     if (request.event.httpMethod === 'GET') {
+ *       // Cleanup Powertools resources
+ *       await cleanupMiddlewares(request);
+ *       // Then return early
+ *       return 'GET method not supported';
+ *     }
+ *   };
+ *
+ *   return {
+ *     before,
+ *   };
+ * };
+ * ```
+ *
+ * @param request The Middy request object
+ */
+declare const cleanupMiddlewares: (request: MiddyLikeRequest) => Promise<void>;
+export { cleanupMiddlewares };
+//# sourceMappingURL=cleanupMiddlewares.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/cleanupMiddlewares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanupMiddlewares.d.ts","sourceRoot":"","sources":["../../../src/middleware/cleanupMiddlewares.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAiB3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,QAAA,MAAM,kBAAkB,YAAmB,gBAAgB,KAAG,OAAO,CAAC,IAAI,CAezE,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/cleanupMiddlewares.js

@@ -0,0 +1,71 @@
+import { IDEMPOTENCY_KEY, LOGGER_KEY, METRICS_KEY, TRACER_KEY, } from './constants.js';
+/**
+ * Typeguard to assert that an object is of Function type.
+ *
+ * @param obj The object to check
+ */
+const isFunction = (obj) => {
+    return typeof obj === 'function';
+};
+/**
+ * Function used to cleanup Powertools for AWS resources when a Middy
+ * middleware [returns early](https://middy.js.org/docs/intro/early-interrupt)
+ * and terminates the middleware chain.
+ *
+ * When a middleware returns early, all the middleware lifecycle functions
+ * that come after it are not executed. This means that if a middleware
+ * was relying on certain logic to be run during the `after` or `onError`
+ * lifecycle functions, that logic will not be executed.
+ *
+ * This is the case for the middlewares that are part of Powertools for AWS
+ * which rely on these lifecycle functions to perform cleanup operations
+ * like closing the current segment in the tracer or flushing any stored
+ * metrics.
+ *
+ * When authoring a middleware that might return early, you can use this
+ * function to cleanup Powertools resources. This function will check if
+ * any cleanup function is present in the `request.internal` object and
+ * execute it.
+ *
+ * @example
+ * ```typescript
+ * import middy from '@middy/core';
+ * import { cleanupMiddlewares } from '@aws-lambda-powertools/commons/lib/middleware';
+ *
+ * // Example middleware that returns early
+ * const myCustomMiddleware = (): middy.MiddlewareObj => {
+ *   const before = async (request: middy.Request): Promise<undefined | string> => {
+ *     // If the request is a GET, return early (as an example)
+ *     if (request.event.httpMethod === 'GET') {
+ *       // Cleanup Powertools resources
+ *       await cleanupMiddlewares(request);
+ *       // Then return early
+ *       return 'GET method not supported';
+ *     }
+ *   };
+ *
+ *   return {
+ *     before,
+ *   };
+ * };
+ * ```
+ *
+ * @param request The Middy request object
+ */
+const cleanupMiddlewares = async (request) => {
+    const cleanupFunctionNames = [
+        TRACER_KEY,
+        METRICS_KEY,
+        LOGGER_KEY,
+        IDEMPOTENCY_KEY,
+    ];
+    for (const functionName of cleanupFunctionNames) {
+        if (Object.hasOwn(request.internal, functionName)) {
+            const functionReference = request.internal[functionName];
+            if (isFunction(functionReference)) {
+                await functionReference(request);
+            }
+        }
+    }
+};
+export { cleanupMiddlewares };

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/constants.d.ts

@@ -0,0 +1,32 @@
+/**
+ * These constants are used to store cleanup functions in Middy's `request.internal` object.
+ * They are used by the `cleanupPowertools` function to check if any cleanup function
+ * is present and execute it.
+ */
+declare const PREFIX = "powertools-for-aws";
+/**
+ * Key to store the tracer instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+declare const TRACER_KEY = "powertools-for-aws.tracer";
+/**
+ * Key to store the metrics instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+declare const METRICS_KEY = "powertools-for-aws.metrics";
+/**
+ * Key to store the logger instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+declare const LOGGER_KEY = "powertools-for-aws.logger";
+/**
+ * Key to store the idempotency instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+declare const IDEMPOTENCY_KEY = "powertools-for-aws.idempotency";
+export { PREFIX, TRACER_KEY, METRICS_KEY, LOGGER_KEY, IDEMPOTENCY_KEY };
+//# sourceMappingURL=constants.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/middleware/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,QAAA,MAAM,MAAM,uBAAuB,CAAC;AACpC;;;;GAIG;AACH,QAAA,MAAM,UAAU,8BAAqB,CAAC;AACtC;;;;GAIG;AACH,QAAA,MAAM,WAAW,+BAAsB,CAAC;AACxC;;;;GAIG;AACH,QAAA,MAAM,UAAU,8BAAqB,CAAC;AACtC;;;;GAIG;AACH,QAAA,MAAM,eAAe,mCAA0B,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,CAAC"}

package/node_modules/@aws-lambda-powertools/commons/lib/esm/middleware/constants.js

@@ -0,0 +1,31 @@
+/**
+ * These constants are used to store cleanup functions in Middy's `request.internal` object.
+ * They are used by the `cleanupPowertools` function to check if any cleanup function
+ * is present and execute it.
+ */
+const PREFIX = 'powertools-for-aws';
+/**
+ * Key to store the tracer instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+const TRACER_KEY = `${PREFIX}.tracer`;
+/**
+ * Key to store the metrics instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+const METRICS_KEY = `${PREFIX}.metrics`;
+/**
+ * Key to store the logger instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+const LOGGER_KEY = `${PREFIX}.logger`;
+/**
+ * Key to store the idempotency instance in the `request.internal` object.
+ *
+ * @see {@link cleanupMiddlewares}
+ */
+const IDEMPOTENCY_KEY = `${PREFIX}.idempotency`;
+export { PREFIX, TRACER_KEY, METRICS_KEY, LOGGER_KEY, IDEMPOTENCY_KEY };

package/node_modules/@aws-lambda-powertools/commons/lib/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/node_modules/@aws-lambda-powertools/commons/lib/esm/typeUtils.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Check if a value is a record.
+ *
+ * @example
+ * ```typescript
+ * import { isRecord } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = { key: 'value' };
+ * if (isRecord(value)) {
+ *   // value is a record
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isRecord: (value: unknown) => value is Record<string | number, unknown>;
+/**
+ * Check if a value is a string.
+ *
+ * @example
+ * ```typescript
+ * import { isString } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = 'foo';
+ * if (isString(value)) {
+ *   // value is a string
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isString: (value: unknown) => value is string;
+/**
+ * Check if a value is a number.
+ *
+ * @example
+ * ```typescript
+ * import { isNumber } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = 42;
+ * if (isNumber(value)) {
+ *   // value is a number
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isNumber: (value: unknown) => value is number;
+/**
+ * Check if a value is an integer number.
+ *
+ * @example
+ * ```typescript
+ * import { isIntegerNumber } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = 42;
+ * if (isIntegerNumber(value)) {
+ *   // value is an integer number
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isIntegerNumber: (value: unknown) => value is number;
+/**
+ * Check if a value is truthy.
+ *
+ * @example
+ * ```typescript
+ * import { isTruthy } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = 'yes';
+ * if (isTruthy(value)) {
+ *   // value is truthy
+ * }
+ * ```
+ *
+ * @see https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/types-grammar/ch4.md#toboolean
+ *
+ * @param value The value to check
+ */
+declare const isTruthy: (value: unknown) => boolean;
+/**
+ * Check if a value is `null`.
+ *
+ * @example
+ * ```typescript
+ * import { isNull } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = null;
+ * if (isNull(value)) {
+ *   // value is null
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isNull: (value: unknown) => value is null;
+/**
+ * Check if a value is `null` or `undefined`.
+ *
+ * @example
+ * ```typescript
+ * import { isNullOrUndefined } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const value = null;
+ * if (isNullOrUndefined(value)) {
+ *   // value is null or undefined
+ * }
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const isNullOrUndefined: (value: unknown) => value is null | undefined;
+/**
+ * Get the type of a value as a string.
+ *
+ * @example
+ * ```typescript
+ * import { getType } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const type = getType('foo'); // 'string'
+ * const otherType = getType(42); // 'number'
+ * const anotherType = getType({ key: 'value' }); // 'object'
+ * const unknownType = getType(Symbol('foo')); // 'unknown'
+ * ```
+ *
+ * @param value The value to check
+ */
+declare const getType: (value: unknown) => string;
+/**
+ * Check if two unknown values are strictly equal.
+ *
+ * If the values are arrays, then each element is compared, regardless of
+ * order. If the values are objects, then each key and value from left
+ * is compared to the corresponding key and value from right. If the
+ * values are primitives, then they are compared using strict equality.
+ *
+ * @example
+ * ```typescript
+ * import { isStrictEqual } from '@aws-lambda-powertools/commons/typeUtils';
+ *
+ * const left = { key: 'value' };
+ * const right = { key: 'value' };
+ * const equal = isStrictEqual(left, right); // true
+ *
+ * const otherLeft = [1, 2, 3];
+ * const otherRight = [3, 2, 1];
+ * const otherEqual = isStrictEqual(otherLeft, otherRight); // true
+ *
+ * const anotherLeft = 'foo';
+ * const anotherRight = 'bar';
+ * const anotherEqual = isStrictEqual(anotherLeft, anotherRight); // false
+ *
+ * const yetAnotherLeft = 42;
+ * const yetAnotherRight = 42;
+ * const yetAnotherEqual = isStrictEqual(yetAnotherLeft, yetAnotherRight); // true
+ * ```
+ *
+ * @param left Left side of strict equality comparison
+ * @param right Right side of strict equality comparison
+ */
+declare const isStrictEqual: (left: unknown, right: unknown) => boolean;
+export { isRecord, isString, isNumber, isIntegerNumber, isTruthy, isNull, isNullOrUndefined, getType, isStrictEqual, };
+//# sourceMappingURL=typeUtils.d.ts.map

package/node_modules/@aws-lambda-powertools/commons/lib/esm/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/typeUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,QAAQ,UACL,OAAO,KACb,KAAK,IAAI,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAK1C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,QAAQ,UAAW,OAAO,KAAG,KAAK,IAAI,MAE3C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,QAAQ,UAAW,OAAO,KAAG,KAAK,IAAI,MAE3C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,eAAe,UAAW,OAAO,KAAG,KAAK,IAAI,MAElD,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,QAAQ,UAAW,OAAO,KAAG,OAkBlC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,MAAM,UAAW,OAAO,KAAG,KAAK,IAAI,IAEzC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,iBAAiB,UAAW,OAAO,KAAG,KAAK,IAAI,IAAI,GAAG,SAE3D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,OAAO,UAAW,OAAO,KAAG,MAqBjC,CAAC;AAgEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,QAAA,MAAM,aAAa,SAAU,OAAO,SAAS,OAAO,KAAG,OAkBtD,CAAC;AAEF,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,MAAM,EACN,iBAAiB,EACjB,OAAO,EACP,aAAa,GACd,CAAC"}