@lafken/common 0.10.1

package/lib/decorators/field/field.types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldProperties = void 0;
+var FieldProperties;
+(function (FieldProperties) {
+    FieldProperties["field"] = "lafken:field";
+    FieldProperties["payload"] = "lafken:payload";
+})(FieldProperties || (exports.FieldProperties = FieldProperties = {}));

package/lib/decorators/field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './field';
+export * from './field.types';

package/lib/decorators/field/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./field"), exports);
+__exportStar(require("./field.types"), exports);

package/lib/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './field';
+export * from './lambda';
+export * from './payload';
+export * from './resource';

package/lib/decorators/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./field"), exports);
+__exportStar(require("./lambda"), exports);
+__exportStar(require("./payload"), exports);
+__exportStar(require("./resource"), exports);

package/lib/decorators/lambda/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lambda';
+export * from './lambda.types';

package/lib/decorators/lambda/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./lambda"), exports);
+__exportStar(require("./lambda.types"), exports);

package/lib/decorators/lambda/lambda.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { type AllowedTypes } from '../field';
+import { type CreateEventDecoratorProps, type CreateLambdaDecoratorProps, LambdaArgumentTypes } from './lambda.types';
+export declare const reflectArgumentMethod: (target: Function, methodName: string, type: LambdaArgumentTypes) => void;
+export declare const createLambdaDecorator: <T, M>({ getLambdaMetadata, descriptorValue, argumentParser, }: CreateLambdaDecoratorProps<T, M>) => (props?: T) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;
+export declare const createEventDecorator: ({ enableInLambdaInvocation, prefix }: CreateEventDecoratorProps) => (eventField: AllowedTypes) => (target: any, methodName: string, _number: number) => void;
+export declare const Context: () => (target: any, methodName: string, _number: number) => void;

package/lib/decorators/lambda/lambda.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.createEventDecorator = exports.createLambdaDecorator = exports.reflectArgumentMethod = void 0;
+require("reflect-metadata");
+const utils_1 = require("../../utils");
+const field_1 = require("../field");
+const lambda_types_1 = require("./lambda.types");
+const argumentsByType = {
+    [lambda_types_1.LambdaArgumentTypes.event]: ({ event }) => event,
+    [lambda_types_1.LambdaArgumentTypes.context]: ({ context }) => context,
+};
+const reflectArgumentMethod = (target, methodName, type) => {
+    const properties = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.arguments, target) || {};
+    properties[methodName] = [type, ...(properties[methodName] || [])];
+    Reflect.defineMetadata(lambda_types_1.LambdaReflectKeys.arguments, properties, target);
+};
+exports.reflectArgumentMethod = reflectArgumentMethod;
+const createLambdaDecorator = ({ getLambdaMetadata, descriptorValue, argumentParser, }) => (props) => (target, methodName, descriptor) => {
+    if ((0, utils_1.isBuildEnvironment)()) {
+        const handlersMetadata = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.handlers, target) || [];
+        Reflect.defineMetadata(lambda_types_1.LambdaReflectKeys.handlers, [...handlersMetadata, getLambdaMetadata(props || {}, methodName)], target);
+    }
+    const lambdaArguments = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.arguments, target);
+    if (descriptorValue) {
+        return descriptorValue(descriptor);
+    }
+    const { value: originalValue } = descriptor;
+    const mapArgumentMethod = {
+        ...argumentsByType,
+        ...argumentParser,
+    };
+    descriptor.value = async (event, context) => {
+        const methodArguments = (lambdaArguments?.[methodName] || []).map((argumentType) => mapArgumentMethod[argumentType]({ event, context, methodName, target }));
+        const response = await originalValue.apply(this, methodArguments);
+        return response;
+    };
+};
+exports.createLambdaDecorator = createLambdaDecorator;
+const reflectEventMetadata = (target, methodName, key, data) => {
+    const argumentsByMethod = Reflect.getMetadata(key, target) || {};
+    Reflect.defineMetadata(key, {
+        ...argumentsByMethod,
+        ...(data ? { [methodName]: data } : {}),
+    }, target);
+};
+const createEventDecorator = ({ enableInLambdaInvocation = false, prefix }) => (eventField) => (target, methodName, _number) => {
+    (0, exports.reflectArgumentMethod)(target, methodName, lambda_types_1.LambdaArgumentTypes.event);
+    if (!eventField || (!enableInLambdaInvocation && !(0, utils_1.isBuildEnvironment)())) {
+        return;
+    }
+    const field = (0, field_1.getEventFields)(prefix, eventField);
+    reflectEventMetadata(target, methodName, lambda_types_1.LambdaReflectKeys.event_param, field);
+};
+exports.createEventDecorator = createEventDecorator;
+const Context = () => (target, methodName, _number) => {
+    (0, exports.reflectArgumentMethod)(target, methodName, lambda_types_1.LambdaArgumentTypes.context);
+};
+exports.Context = Context;

package/lib/decorators/lambda/lambda.types.d.ts

@@ -0,0 +1,204 @@
+import type { EnvironmentValue, GetResourceProps } from '../../types';
+import type { ServicesValues } from '../../types/services.types';
+export interface VpcConfig {
+    /**
+     * Enables IPv6 for dual-stack networking.
+     *
+     * When set to `true`, the Lambda function will support both IPv4 and IPv6
+     * traffic within the VPC. This is useful when the VPC subnets are configured
+     * with dual-stack addressing.
+     *
+     * @default false
+     */
+    ipv6AllowedForDualStack?: boolean;
+    /**
+     * Security group IDs to associate with the Lambda function.
+     *
+     * Specifies one or more VPC security groups that control inbound and outbound
+     * network traffic for the Lambda function. These security groups determine
+     * which resources the Lambda can communicate with inside and outside the VPC.
+     */
+    securityGroupIds: string[];
+    /**
+     * Subnet IDs where the Lambda function will be deployed.
+     *
+     * Specifies one or more VPC subnets in which the Lambda function will run.
+     * To ensure high availability, it is recommended to provide subnets across
+     * multiple Availability Zones.
+     */
+    subnetIds: string[];
+}
+export type VpcConfigValue = VpcConfig | ((props: Pick<GetResourceProps, 'getSSMValue'>) => VpcConfig);
+export interface AliasConfig {
+    /**
+     * The name of the Lambda alias.
+     *
+     * This name will be used to create an AWS Lambda alias pointing to the
+     * latest published version of the function. The alias acts as a stable
+     * reference to a specific function version.
+     */
+    name: string;
+    /**
+     * Number of provisioned concurrent executions for this alias.
+     *
+     * When set to a value greater than 0, a `LambdaProvisionedConcurrencyConfig`
+     * will be created, ensuring that the specified number of execution environments
+     * are initialized and ready to respond immediately to invocations.
+     *
+     * This helps reduce cold start latency for latency-sensitive workloads.
+     *
+     * @default undefined (no provisioned concurrency)
+     */
+    provisionedExecutions?: number;
+}
+export interface LambdaProps {
+    /**
+     * Lambda execution timeout.
+     *
+     * Specifies the maximum amount of time (in seconds) that the Lambda
+     * function is allowed to run before being terminated. If the execution
+     * exceeds this limit, the function will be stopped and an error will be raised.
+     */
+    timeout?: number;
+    /**
+     * Lambda memory allocation.
+     *
+     * Specifies the amount of memory (in MB) allocated to the Lambda function.
+     * Increasing memory also increases the CPU and network resources proportionally.
+     */
+    memory?: number;
+    /**
+     * Lambda NodeJS runtime
+     *
+     * Defines the Node.js runtime environment that the Lambda will use
+     * during execution. Only supported LTS versions are allowed to ensure
+     * long-term stability and AWS compatibility.
+     *
+     * Supported values:
+     * - `24` → Node.js 24
+     * - `22` → Node.js 22
+     * - `20` → Node.js 20
+     */
+    runtime?: 24 | 22 | 20;
+    /**
+     * Lambda services.
+     *
+     * Defines which AWS services the Lambda function is allowed to access.
+     * Internally, a role is created with the specified service permissions,
+     * granting the Lambda the ability to interact with those resources.
+     */
+    services?: ServicesValues;
+    /**
+     * Lambda environments.
+     *
+     * Defines environment values that will be applied specifically to
+     * this Lambda. These values override any global or stack-level
+     * environment configuration.
+     *
+     * Values can be provided in three formats:
+     * 1. `string` - The value will be taken from the `.env` file if present.
+     * 2. `Record<string, string | number | boolean | EnvFunction>` - Directly provides the value as a string.
+     * 3. `Record<string, EnvFunction>` - Functions can compute dynamic values based on resources
+     *    created in the project, using the `getResourceValue` helper.
+     *
+     * @example
+     * // Load value from .env
+     * ["ENV_VALUE"]
+     *
+     * @example
+     * // Provide static values
+     * [
+     *   { "ENV_VALUE": "static_string" },
+     *   { "ENV_NUMBER": 123 }
+     * ]
+     *
+     * @example
+     * // Provide dynamic values from resources
+     * [
+     *   {
+     *     "ENV_VALUE": {
+     *       name: "any",
+     *       other: ({ getResourceValue }) => getResourceValue("s3_bucket", "arn")
+     *     }
+     *   }
+     * ]
+     */
+    env?: EnvironmentValue;
+    /**
+     * Lambda tags.
+     *
+     * Specifies a set of tags that will be applied to lambda function.
+     */
+    tags?: Record<string, string>;
+    /**
+     * Enables AWS X-Ray tracing for Lambda function.
+     *
+     * When set to `true`, X-Ray tracing is activated, allowing you to
+     * collect detailed information about requests, performance, and
+     * interactions with other AWS services.
+     *
+     * This is useful for debugging, monitoring, and gaining visibility
+     * into the execution flow of your Lambda.
+     */
+    enableTrace?: boolean;
+    /**
+     * VPC configuration for the Lambda function.
+     *
+     * When provided, the Lambda function will be deployed inside the specified
+     * VPC, allowing it to access private resources such as RDS databases,
+     * ElastiCache clusters, or internal services that are not publicly accessible.
+     *
+     * Requires specifying at least one subnet and one security group.
+     */
+    vpcConfig?: VpcConfigValue;
+    /**
+     * Alias configuration for the Lambda function.
+     *
+     * When provided, the Lambda function will be published (creating a new version)
+     * and a Lambda alias will be created pointing to the latest published version.
+     *
+     * If `provisionedExecutions` is set to a value greater than 0, a provisioned
+     * concurrency configuration will also be created for the alias to reduce
+     * cold start latency.
+     *
+     * @example
+     * // Create an alias without provisioned concurrency
+     * { name: 'live' }
+     *
+     * @example
+     * // Create an alias with provisioned concurrency
+     * { name: 'live', provisionedExecutions: 5 }
+     */
+    alias?: AliasConfig;
+}
+export interface LambdaMetadata {
+    name: string;
+    lambda?: LambdaProps;
+    description?: string;
+}
+export declare enum LambdaReflectKeys {
+    handlers = "lambda:handlers",
+    arguments = "lambda:arguments",
+    event_param = "lambda:event_params"
+}
+export declare enum LambdaArgumentTypes {
+    event = "event",
+    context = "context"
+}
+export type CallbackParam = (error: boolean | null, response?: any) => void;
+export type LambdaArguments = Record<string, LambdaArgumentTypes[]>;
+export type LambdaArgumentsType = Record<LambdaArgumentTypes, ({ event, context, }: {
+    event: any;
+    context: any;
+    methodName: string;
+    target: any;
+}) => any>;
+export interface CreateLambdaDecoratorProps<T, M> {
+    getLambdaMetadata: (params: T, methodName: string) => M;
+    descriptorValue?: (descriptor: PropertyDescriptor) => any;
+    argumentParser?: Partial<LambdaArgumentsType | (string & {})>;
+}
+export interface CreateEventDecoratorProps {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+}

package/lib/decorators/lambda/lambda.types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaArgumentTypes = exports.LambdaReflectKeys = void 0;
+var LambdaReflectKeys;
+(function (LambdaReflectKeys) {
+    LambdaReflectKeys["handlers"] = "lambda:handlers";
+    LambdaReflectKeys["arguments"] = "lambda:arguments";
+    LambdaReflectKeys["event_param"] = "lambda:event_params";
+})(LambdaReflectKeys || (exports.LambdaReflectKeys = LambdaReflectKeys = {}));
+var LambdaArgumentTypes;
+(function (LambdaArgumentTypes) {
+    LambdaArgumentTypes["event"] = "event";
+    LambdaArgumentTypes["context"] = "context";
+})(LambdaArgumentTypes || (exports.LambdaArgumentTypes = LambdaArgumentTypes = {}));

package/lib/decorators/payload/index.d.ts

@@ -0,0 +1,2 @@
+export * from './payload';
+export * from './payload.types';

package/lib/decorators/payload/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./payload"), exports);
+__exportStar(require("./payload.types"), exports);

package/lib/decorators/payload/payload.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePayloadDecoratorProps, PayloadProps } from './payload.types';
+export declare const createPayloadDecorator: <T extends PayloadProps, M>({ prefix, getMetadata, createUniqueId, enableInLambdaInvocation, }: CreatePayloadDecoratorProps<T, M>) => (props?: T) => (target: Function) => void;

package/lib/decorators/payload/payload.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPayloadDecorator = void 0;
+const utils_1 = require("../../utils");
+const field_1 = require("../field");
+const payloadIds = {};
+const createPayloadDecorator = ({ prefix, getMetadata, createUniqueId = false, enableInLambdaInvocation = false, }) => (props) => (target) => {
+    if (!(0, utils_1.isBuildEnvironment)() && !enableInLambdaInvocation) {
+        return;
+    }
+    const { name = target.name } = props || {};
+    let id = name;
+    if (createUniqueId) {
+        payloadIds[name] ??= 0;
+        if (payloadIds[name] > 0) {
+            id = `${name}_${payloadIds[name]}`;
+        }
+        payloadIds[name]++;
+    }
+    let payloadMetadata = {
+        id,
+        name,
+    };
+    if (getMetadata) {
+        payloadMetadata = {
+            ...payloadMetadata,
+            ...getMetadata(props),
+        };
+    }
+    Reflect.defineMetadata(`${prefix}:${field_1.FieldProperties.payload}`, payloadMetadata, target);
+};
+exports.createPayloadDecorator = createPayloadDecorator;

package/lib/decorators/payload/payload.types.d.ts

@@ -0,0 +1,18 @@
+export interface PayloadProps {
+    /**
+     * Payload name.
+     *
+     * Specifies the name of the payload, which is used to identify
+     * it within the application or during data processing.
+     */
+    name?: string;
+}
+export interface PayloadMetadata extends Required<PayloadProps> {
+    id: string;
+}
+export interface CreatePayloadDecoratorProps<P extends PayloadProps, M> {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+    createUniqueId?: boolean;
+    getMetadata?: (props?: P) => Omit<M, keyof PayloadMetadata>;
+}

package/lib/decorators/payload/payload.types.js

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

package/lib/decorators/resource/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resource';
+export * from './resource.types';

package/lib/decorators/resource/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./resource"), exports);
+__exportStar(require("./resource.types"), exports);

package/lib/decorators/resource/resource.d.ts

@@ -0,0 +1,2 @@
+import { type ResourceDecoratorProps, type ResourceProps } from './resource.types';
+export declare const createResourceDecorator: <T extends ResourceProps>(decoratorProps: ResourceDecoratorProps<T>) => (props?: T) => (constructor: Function) => void;

package/lib/decorators/resource/resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceDecorator = void 0;
+const node_path_1 = require("node:path");
+const utils_1 = require("../../utils");
+const path_utils_1 = require("../../utils/path.utils");
+const resource_types_1 = require("./resource.types");
+const createResourceDecorator = (decoratorProps) => (props) => (constructor) => {
+    if (!(0, utils_1.isBuildEnvironment)()) {
+        return;
+    }
+    const { type, callerFileIndex, getMetadata = () => props } = decoratorProps;
+    const additionalMetadata = getMetadata(props || {});
+    const callerFile = (0, path_utils_1.getCallerFileName)(callerFileIndex);
+    Reflect.defineMetadata(resource_types_1.ResourceReflectKeys.resource, {
+        ...additionalMetadata,
+        type,
+        name: props?.name || constructor.name,
+        foldername: (0, node_path_1.dirname)(callerFile),
+        filename: (0, node_path_1.basename)(callerFile).replace('.js', ''),
+        originalName: constructor.name,
+        minify: props?.minify ?? true,
+    }, constructor);
+};
+exports.createResourceDecorator = createResourceDecorator;

package/lib/decorators/resource/resource.types.d.ts

@@ -0,0 +1,31 @@
+export declare enum ResourceReflectKeys {
+    resource = "resource"
+}
+export interface ResourceProps {
+    /**
+     * Resource name.
+     *
+     * Specifies the name of the resource. This name is used to identify
+     * the resource within the application, stack, or deployment.
+     */
+    name?: string;
+    /**
+     * Resource minify
+     *
+     * Specifies whether the code should be minified when the resource is processed
+     *
+     * @default true
+     */
+    minify?: boolean;
+}
+export interface ResourceMetadata extends Required<ResourceProps> {
+    type: string;
+    filename: string;
+    foldername: string;
+    originalName: string;
+}
+export interface ResourceDecoratorProps<T> {
+    type: string;
+    callerFileIndex?: number;
+    getMetadata?: (props: T) => T;
+}

package/lib/decorators/resource/resource.types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceReflectKeys = void 0;
+var ResourceReflectKeys;
+(function (ResourceReflectKeys) {
+    ResourceReflectKeys["resource"] = "resource";
+})(ResourceReflectKeys || (exports.ResourceReflectKeys = ResourceReflectKeys = {}));

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants/env.constants';
+export * from './decorators';
+export * from './types';
+export * from './utils';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./constants/env.constants"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/lib/types/env.types.d.ts

@@ -0,0 +1,4 @@
+import type { GetResourceProps } from './resource.types';
+type EvnFunction = (props: GetResourceProps) => Record<string, string>;
+export type EnvironmentValue = Record<string, string> | EvnFunction;
+export {};

package/lib/types/env.types.js

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

package/lib/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './env.types';
+export * from './output.types';
+export * from './override-resources.types';
+export * from './resource.types';
+export * from './services.types';
+export * from './time.types';
+export * from './utilities.types';

package/lib/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./env.types"), exports);
+__exportStar(require("./output.types"), exports);
+__exportStar(require("./override-resources.types"), exports);
+__exportStar(require("./resource.types"), exports);
+__exportStar(require("./services.types"), exports);
+__exportStar(require("./time.types"), exports);
+__exportStar(require("./utilities.types"), exports);