@geekmidas/envkit 0.0.3 → 0.0.5

package/dist/__tests__/EnvironmentParser.spec.mjs

@@ -1,6 +1,6 @@
-import { describe, globalExpect, it } from "../vi.bdSIJ99Y-CkiV-M6Y.mjs";
-import { EnvironmentParser } from "../EnvironmentParser-Boj5EFmL.mjs";
+import { EnvironmentParser } from "../EnvironmentParser-CQUOGqc0.mjs";
 import { z } from "zod/v4";
+import { describe, expect, it } from "vitest";
 
 //#region src/__tests__/EnvironmentParser.spec.ts
 describe("EnvironmentParser", () => {
@@ -9,7 +9,7 @@ describe("EnvironmentParser", () => {
 			const env = { APP_NAME: "Test App" };
 			const parser = new EnvironmentParser(env);
 			const config = parser.create((get) => ({ appName: get("APP_NAME").string() })).parse();
-			globalExpect(config).toEqual({ appName: "Test App" });
+			expect(config).toEqual({ appName: "Test App" });
 		});
 		it("should parse with default values when env var is missing", () => {
 			const env = {};
@@ -18,7 +18,7 @@ describe("EnvironmentParser", () => {
 				appName: get("APP_NAME").string().default("Default App"),
 				port: get("PORT").string().transform(Number).default(3e3)
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				appName: "Default App",
 				port: 3e3
 			});
@@ -27,7 +27,7 @@ describe("EnvironmentParser", () => {
 			const env = { PORT: "8080" };
 			const parser = new EnvironmentParser(env);
 			const config = parser.create((get) => ({ port: get("PORT").string().transform(Number) })).parse();
-			globalExpect(config).toEqual({ port: 8080 });
+			expect(config).toEqual({ port: 8080 });
 		});
 		it("should transform string to boolean", () => {
 			const env = {
@@ -41,7 +41,7 @@ describe("EnvironmentParser", () => {
 				disabled: get("FEATURE_DISABLED").string().transform((v) => v === "true"),
 				truthy: get("FEATURE_TRUTHY").string().transform((v) => v === "true")
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				enabled: true,
 				disabled: false,
 				truthy: false
@@ -54,7 +54,7 @@ describe("EnvironmentParser", () => {
 				required: get("REQUIRED").string(),
 				optional: get("OPTIONAL").string().optional()
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				required: "value",
 				optional: void 0
 			});
@@ -69,7 +69,7 @@ describe("EnvironmentParser", () => {
 				apiUrl: get("VALID_URL").string().url(),
 				dbUrl: get("DATABASE_URL").string().url()
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				apiUrl: "https://example.com",
 				dbUrl: "postgresql://user:pass@localhost:5432/db"
 			});
@@ -78,7 +78,7 @@ describe("EnvironmentParser", () => {
 			const env = { ADMIN_EMAIL: "admin@example.com" };
 			const parser = new EnvironmentParser(env);
 			const config = parser.create((get) => ({ adminEmail: get("ADMIN_EMAIL").string().email() })).parse();
-			globalExpect(config).toEqual({ adminEmail: "admin@example.com" });
+			expect(config).toEqual({ adminEmail: "admin@example.com" });
 		});
 		it("should validate enums", () => {
 			const env = { NODE_ENV: "production" };
@@ -88,7 +88,7 @@ describe("EnvironmentParser", () => {
 				"staging",
 				"production"
 			]) })).parse();
-			globalExpect(config).toEqual({ env: "production" });
+			expect(config).toEqual({ env: "production" });
 		});
 	});
 	describe("Nested configuration", () => {
@@ -112,7 +112,7 @@ describe("EnvironmentParser", () => {
 					url: get("API_URL").string().url()
 				}
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				database: {
 					host: "localhost",
 					port: 5432,
@@ -142,7 +142,7 @@ describe("EnvironmentParser", () => {
 					ttl: get("FEATURE_CACHE_TTL").string().transform(Number)
 				}
 			} })).parse();
-			globalExpect(config).toEqual({ features: {
+			expect(config).toEqual({ features: {
 				authentication: {
 					enabled: true,
 					provider: "oauth"
@@ -171,7 +171,7 @@ describe("EnvironmentParser", () => {
 					ttl: get("REDIS_TTL").string().transform(Number)
 				} }
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				database: {
 					host: "custom-host",
 					port: 5432,
@@ -189,7 +189,7 @@ describe("EnvironmentParser", () => {
 		it("should throw ZodError for missing required values", () => {
 			const env = {};
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ required: get("REQUIRED_VAR").string() })).parse();
 			}).toThrow(z.ZodError);
 		});
@@ -202,24 +202,24 @@ describe("EnvironmentParser", () => {
 					dbUrl: get("DATABASE_URL").string().url()
 				})).parse();
 			} catch (error) {
-				globalExpect(error).toBeInstanceOf(z.ZodError);
+				expect(error).toBeInstanceOf(z.ZodError);
 				const zodError = error;
-				globalExpect(zodError.issues).toHaveLength(2);
-				globalExpect(zodError.issues[0].message).toContain("Environment variable \"API_KEY\"");
-				globalExpect(zodError.issues[1].message).toContain("Environment variable \"DATABASE_URL\"");
+				expect(zodError.issues).toHaveLength(2);
+				expect(zodError.issues[0].message).toContain("Environment variable \"API_KEY\"");
+				expect(zodError.issues[1].message).toContain("Environment variable \"DATABASE_URL\"");
 			}
 		});
 		it("should validate minimum string length", () => {
 			const env = { API_KEY: "short" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ apiKey: get("API_KEY").string().min(32) })).parse();
 			}).toThrow(z.ZodError);
 		});
 		it("should validate maximum string length", () => {
 			const env = { SHORT_TEXT: "a".repeat(100) };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ shortText: get("SHORT_TEXT").string().max(50) })).parse();
 			}).toThrow(z.ZodError);
 		});
@@ -230,29 +230,29 @@ describe("EnvironmentParser", () => {
 			};
 			const parser = new EnvironmentParser(env);
 			const validConfig = parser.create((get) => ({ key: get("VALID_KEY").string().length(32) })).parse();
-			globalExpect(validConfig).toEqual({ key: "a".repeat(32) });
-			globalExpect(() => {
+			expect(validConfig).toEqual({ key: "a".repeat(32) });
+			expect(() => {
 				parser.create((get) => ({ key: get("INVALID_KEY").string().length(32) })).parse();
 			}).toThrow(z.ZodError);
 		});
 		it("should validate invalid URLs", () => {
 			const env = { INVALID_URL: "not-a-url" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ url: get("INVALID_URL").string().url() })).parse();
 			}).toThrow(z.ZodError);
 		});
 		it("should validate invalid email addresses", () => {
 			const env = { INVALID_EMAIL: "not-an-email" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ email: get("INVALID_EMAIL").string().email() })).parse();
 			}).toThrow(z.ZodError);
 		});
 		it("should validate invalid enum values", () => {
 			const env = { NODE_ENV: "invalid" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ env: get("NODE_ENV").enum([
 					"development",
 					"staging",
@@ -268,18 +268,18 @@ describe("EnvironmentParser", () => {
 			};
 			const parser = new EnvironmentParser(env);
 			const validConfig = parser.create((get) => ({ port: get("VALID_PORT").coerce.number().min(1).max(65535) })).parse();
-			globalExpect(validConfig).toEqual({ port: 8080 });
-			globalExpect(() => {
+			expect(validConfig).toEqual({ port: 8080 });
+			expect(() => {
 				parser.create((get) => ({ port: get("INVALID_PORT_LOW").coerce.number().min(1).max(65535) })).parse();
 			}).toThrow(z.ZodError);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ port: get("INVALID_PORT_HIGH").coerce.number().min(1).max(65535) })).parse();
 			}).toThrow(z.ZodError);
 		});
 		it("should handle transformation errors", () => {
 			const env = { INVALID_NUMBER: "not-a-number" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ number: get("INVALID_NUMBER").string().transform((v) => {
 					const num = Number(v);
 					if (isNaN(num)) throw new Error("Invalid number");
@@ -299,7 +299,7 @@ describe("EnvironmentParser", () => {
 				cors: { origins: get("ALLOWED_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())) },
 				features: get("FEATURE_FLAGS").string().transform((flags) => flags.split(",").map((f) => f.trim()))
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				cors: { origins: [
 					"http://localhost:3000",
 					"https://example.com",
@@ -325,7 +325,7 @@ describe("EnvironmentParser", () => {
 					window: z.number()
 				}))
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				features: {
 					auth: true,
 					cache: false,
@@ -347,7 +347,7 @@ describe("EnvironmentParser", () => {
 				cors: { origins: get("CORS_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())).refine((origins) => origins.every((o) => o.startsWith("https://")), { message: "All CORS origins must use HTTPS" }) },
 				apiKeys: get("API_KEYS").string().transform((keys) => keys.split(",").map((k) => k.trim())).pipe(z.array(z.string().min(32)))
 			})).parse();
-			globalExpect(config).toEqual({
+			expect(config).toEqual({
 				cors: { origins: ["https://example.com", "https://app.example.com"] },
 				apiKeys: ["key1234567890123456789012345678901", "key2345678901234567890123456789012"]
 			});
@@ -355,7 +355,7 @@ describe("EnvironmentParser", () => {
 		it("should fail refinements with descriptive errors", () => {
 			const env = { CORS_ORIGINS: "http://example.com,https://app.example.com" };
 			const parser = new EnvironmentParser(env);
-			globalExpect(() => {
+			expect(() => {
 				parser.create((get) => ({ cors: { origins: get("CORS_ORIGINS").string().transform((origins) => origins.split(",").map((o) => o.trim())).refine((origins) => origins.every((o) => o.startsWith("https://")), { message: "All CORS origins must use HTTPS" }) } })).parse();
 			}).toThrow(z.ZodError);
 		});
@@ -367,8 +367,8 @@ describe("EnvironmentParser", () => {
 			const config = parser.create((get) => ({ appName: get("APP_NAME").string() })).parse();
 			const _typeCheck = true;
 			const _typeCheck2 = true;
-			globalExpect(_typeCheck).toBe(true);
-			globalExpect(_typeCheck2).toBe(true);
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
 		});
 		it("should correctly infer number types after transformation", () => {
 			const env = { PORT: "3000" };
@@ -376,8 +376,8 @@ describe("EnvironmentParser", () => {
 			const config = parser.create((get) => ({ port: get("PORT").string().transform(Number) })).parse();
 			const _typeCheck = true;
 			const _typeCheck2 = true;
-			globalExpect(_typeCheck).toBe(true);
-			globalExpect(_typeCheck2).toBe(true);
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
 		});
 		it("should correctly infer boolean types after transformation", () => {
 			const env = { FEATURE_ENABLED: "true" };
@@ -385,8 +385,8 @@ describe("EnvironmentParser", () => {
 			const config = parser.create((get) => ({ enabled: get("FEATURE_ENABLED").string().transform((v) => v === "true") })).parse();
 			const _typeCheck = true;
 			const _typeCheck2 = true;
-			globalExpect(_typeCheck).toBe(true);
-			globalExpect(_typeCheck2).toBe(true);
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
 		});
 		it("should correctly infer optional types", () => {
 			const env = { REQUIRED: "value" };
@@ -412,8 +412,8 @@ describe("EnvironmentParser", () => {
 			})).parse();
 			const _typeCheck = true;
 			const _typeCheck2 = true;
-			globalExpect(_typeCheck).toBe(true);
-			globalExpect(_typeCheck2).toBe(true);
+			expect(_typeCheck).toBe(true);
+			expect(_typeCheck2).toBe(true);
 		});
 	});
 });

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/index.cjs

@@ -1,3 +1,3 @@
-const require_EnvironmentParser = require('./EnvironmentParser-Bz9IoLJs.cjs');
+const require_EnvironmentParser = require('./EnvironmentParser-BDPDLv6i.cjs');
 
 exports.EnvironmentParser = require_EnvironmentParser.EnvironmentParser;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { EnvironmentParser } from "./EnvironmentParser-X4h2Vp4r.cjs";
+export { EnvironmentParser };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { EnvironmentParser } from "./EnvironmentParser-BD6NmvPR.mjs";
+export { EnvironmentParser };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { EnvironmentParser } from "./EnvironmentParser-Boj5EFmL.mjs";
+import { EnvironmentParser } from "./EnvironmentParser-CQUOGqc0.mjs";
 
 export { EnvironmentParser };

package/dist/sst.cjs

@@ -0,0 +1,131 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const lodash_snakecase = require_chunk.__toESM(require("lodash.snakecase"));
+
+//#region src/sst.ts
+/**
+* Converts a string to environment variable case format (UPPER_SNAKE_CASE).
+* Numbers following underscores are preserved without the underscore.
+*
+* @param name - The string to convert
+* @returns The converted string in environment variable format
+*
+* @example
+* environmentCase('myVariable') // 'MY_VARIABLE'
+* environmentCase('api_v2') // 'APIV2'
+*/
+function environmentCase(name) {
+	return (0, lodash_snakecase.default)(name).toUpperCase().replace(/_\d+/g, (r) => {
+		return r.replace("_", "");
+	});
+}
+/**
+* Enumeration of supported SST (Serverless Stack Toolkit) resource types.
+* Used to identify and process different AWS and SST resources.
+*/
+let ResourceType = /* @__PURE__ */ function(ResourceType$1) {
+	ResourceType$1["ApiGatewayV2"] = "sst.aws.ApiGatewayV2";
+	ResourceType$1["Postgres"] = "sst.aws.Postgres";
+	ResourceType$1["Function"] = "sst.aws.Function";
+	ResourceType$1["Bucket"] = "sst.aws.Bucket";
+	ResourceType$1["Vpc"] = "sst.aws.Vpc";
+	ResourceType$1["Secret"] = "sst.sst.Secret";
+	ResourceType$1["SSTSecret"] = "sst:sst:Secret";
+	ResourceType$1["SSTFunction"] = "sst:sst:Function";
+	ResourceType$1["SSTApiGatewayV2"] = "sst:aws:ApiGatewayV2";
+	ResourceType$1["SSTPostgres"] = "sst:aws:Postgres";
+	ResourceType$1["SSTBucket"] = "sst:aws:Bucket";
+	return ResourceType$1;
+}({});
+/**
+* Processes a Secret resource into environment variables.
+*
+* @param name - The resource name
+* @param value - The Secret resource
+* @returns Object with environment variable mappings
+*/
+const secret = (name, value) => ({ [environmentCase(name)]: value.value });
+/**
+* Processes a Postgres database resource into environment variables.
+* Creates multiple environment variables for database connection details.
+*
+* @param key - The resource key
+* @param value - The Postgres resource
+* @returns Object with database connection environment variables
+*/
+const postgres = (key, value) => {
+	const prefix = `${environmentCase(key)}`;
+	return {
+		[`${prefix}_NAME`]: value.database,
+		[`${prefix}_HOST`]: value.host,
+		[`${prefix}_PASSWORD`]: value.password,
+		[`${prefix}_PORT`]: value.port,
+		[`${prefix}_USERNAME`]: value.username
+	};
+};
+/**
+* Processes a Bucket resource into environment variables.
+*
+* @param name - The resource name
+* @param value - The Bucket resource
+* @returns Object with bucket name environment variable
+*/
+const bucket = (name, value) => {
+	const prefix = `${environmentCase(name)}`;
+	return { [`${prefix}_NAME`]: value.name };
+};
+/**
+* No-operation processor for resources that don't require environment variables.
+*
+* @param name - The resource name (unused)
+* @param value - The resource value (unused)
+* @returns Empty object
+*/
+const noop = (name, value) => ({});
+/**
+* Map of resource types to their corresponding processor functions.
+* Each processor converts resource data into environment variables.
+*/
+const processors = {
+	[ResourceType.ApiGatewayV2]: noop,
+	[ResourceType.Function]: noop,
+	[ResourceType.Vpc]: noop,
+	[ResourceType.Secret]: secret,
+	[ResourceType.Postgres]: postgres,
+	[ResourceType.Bucket]: bucket,
+	[ResourceType.SSTSecret]: secret,
+	[ResourceType.SSTBucket]: bucket,
+	[ResourceType.SSTFunction]: noop,
+	[ResourceType.SSTPostgres]: postgres,
+	[ResourceType.SSTApiGatewayV2]: noop
+};
+/**
+* Normalizes SST resources and plain strings into environment variables.
+* Processes resources based on their type and converts names to environment case.
+*
+* @param record - Object containing resources and/or string values
+* @returns Normalized environment variables object
+*
+* @example
+* normalizeResourceEnv({
+*   apiUrl: 'https://api.example.com',
+*   database: { type: ResourceType.Postgres, ... }
+* })
+*/
+function normalizeResourceEnv(record) {
+	const env = {};
+	for (const [k, value] of Object.entries(record)) {
+		if (typeof value === "string") {
+			env[environmentCase(k)] = value;
+			continue;
+		}
+		const processor = processors[value.type];
+		if (processor) Object.assign(env, processor(k, value));
+		else console.warn(`No processor found for resource type: `, { value });
+	}
+	return env;
+}
+
+//#endregion
+exports.ResourceType = ResourceType;
+exports.environmentCase = environmentCase;
+exports.normalizeResourceEnv = normalizeResourceEnv;

package/dist/sst.d.cts

@@ -0,0 +1,107 @@
+//#region src/sst.d.ts
+/**
+ * Converts a string to environment variable case format (UPPER_SNAKE_CASE).
+ * Numbers following underscores are preserved without the underscore.
+ *
+ * @param name - The string to convert
+ * @returns The converted string in environment variable format
+ *
+ * @example
+ * environmentCase('myVariable') // 'MY_VARIABLE'
+ * environmentCase('api_v2') // 'APIV2'
+ */
+declare function environmentCase(name: string): string;
+/**
+ * Enumeration of supported SST (Serverless Stack Toolkit) resource types.
+ * Used to identify and process different AWS and SST resources.
+ */
+declare enum ResourceType {
+  ApiGatewayV2 = "sst.aws.ApiGatewayV2",
+  Postgres = "sst.aws.Postgres",
+  Function = "sst.aws.Function",
+  Bucket = "sst.aws.Bucket",
+  Vpc = "sst.aws.Vpc",
+  Secret = "sst.sst.Secret",
+  SSTSecret = "sst:sst:Secret",
+  SSTFunction = "sst:sst:Function",
+  SSTApiGatewayV2 = "sst:aws:ApiGatewayV2",
+  SSTPostgres = "sst:aws:Postgres",
+  SSTBucket = "sst:aws:Bucket",
+}
+/**
+ * Normalizes SST resources and plain strings into environment variables.
+ * Processes resources based on their type and converts names to environment case.
+ *
+ * @param record - Object containing resources and/or string values
+ * @returns Normalized environment variables object
+ *
+ * @example
+ * normalizeResourceEnv({
+ *   apiUrl: 'https://api.example.com',
+ *   database: { type: ResourceType.Postgres, ... }
+ * })
+ */
+declare function normalizeResourceEnv(record: Record<string, Resource | string>): Record<string, string>;
+/**
+ * AWS API Gateway V2 resource type.
+ * Represents an HTTP/WebSocket API.
+ */
+type ApiGatewayV2 = {
+  type: ResourceType.ApiGatewayV2;
+  url: string;
+};
+/**
+ * PostgreSQL database resource type.
+ * Contains all connection details needed to connect to the database.
+ */
+type Postgres = {
+  database: string;
+  host: string;
+  password: string;
+  port: number;
+  type: ResourceType.Postgres;
+  username: string;
+};
+/**
+ * AWS Lambda Function resource type.
+ */
+type Function = {
+  name: string;
+  type: ResourceType.Function;
+};
+/**
+ * AWS S3 Bucket resource type.
+ */
+type Bucket = {
+  name: string;
+  type: ResourceType.Bucket;
+};
+/**
+ * AWS VPC (Virtual Private Cloud) resource type.
+ */
+type Vpc = {
+  bastion: string;
+  type: ResourceType.Vpc;
+};
+/**
+ * Secret resource type for storing sensitive values.
+ */
+type Secret = {
+  type: ResourceType.Secret;
+  value: string;
+};
+/**
+ * Union type of all supported SST resource types.
+ */
+type Resource = ApiGatewayV2 | Postgres | Function | Bucket | Vpc | Secret;
+/**
+ * Function type for processing a specific resource type into environment variables.
+ *
+ * @template K - The specific resource type
+ * @param name - The resource name
+ * @param value - The resource value
+ * @returns Object mapping environment variable names to values
+ */
+type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
+//#endregion
+export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };

package/dist/sst.d.mts

@@ -0,0 +1,107 @@
+//#region src/sst.d.ts
+/**
+ * Converts a string to environment variable case format (UPPER_SNAKE_CASE).
+ * Numbers following underscores are preserved without the underscore.
+ *
+ * @param name - The string to convert
+ * @returns The converted string in environment variable format
+ *
+ * @example
+ * environmentCase('myVariable') // 'MY_VARIABLE'
+ * environmentCase('api_v2') // 'APIV2'
+ */
+declare function environmentCase(name: string): string;
+/**
+ * Enumeration of supported SST (Serverless Stack Toolkit) resource types.
+ * Used to identify and process different AWS and SST resources.
+ */
+declare enum ResourceType {
+  ApiGatewayV2 = "sst.aws.ApiGatewayV2",
+  Postgres = "sst.aws.Postgres",
+  Function = "sst.aws.Function",
+  Bucket = "sst.aws.Bucket",
+  Vpc = "sst.aws.Vpc",
+  Secret = "sst.sst.Secret",
+  SSTSecret = "sst:sst:Secret",
+  SSTFunction = "sst:sst:Function",
+  SSTApiGatewayV2 = "sst:aws:ApiGatewayV2",
+  SSTPostgres = "sst:aws:Postgres",
+  SSTBucket = "sst:aws:Bucket",
+}
+/**
+ * Normalizes SST resources and plain strings into environment variables.
+ * Processes resources based on their type and converts names to environment case.
+ *
+ * @param record - Object containing resources and/or string values
+ * @returns Normalized environment variables object
+ *
+ * @example
+ * normalizeResourceEnv({
+ *   apiUrl: 'https://api.example.com',
+ *   database: { type: ResourceType.Postgres, ... }
+ * })
+ */
+declare function normalizeResourceEnv(record: Record<string, Resource | string>): Record<string, string>;
+/**
+ * AWS API Gateway V2 resource type.
+ * Represents an HTTP/WebSocket API.
+ */
+type ApiGatewayV2 = {
+  type: ResourceType.ApiGatewayV2;
+  url: string;
+};
+/**
+ * PostgreSQL database resource type.
+ * Contains all connection details needed to connect to the database.
+ */
+type Postgres = {
+  database: string;
+  host: string;
+  password: string;
+  port: number;
+  type: ResourceType.Postgres;
+  username: string;
+};
+/**
+ * AWS Lambda Function resource type.
+ */
+type Function = {
+  name: string;
+  type: ResourceType.Function;
+};
+/**
+ * AWS S3 Bucket resource type.
+ */
+type Bucket = {
+  name: string;
+  type: ResourceType.Bucket;
+};
+/**
+ * AWS VPC (Virtual Private Cloud) resource type.
+ */
+type Vpc = {
+  bastion: string;
+  type: ResourceType.Vpc;
+};
+/**
+ * Secret resource type for storing sensitive values.
+ */
+type Secret = {
+  type: ResourceType.Secret;
+  value: string;
+};
+/**
+ * Union type of all supported SST resource types.
+ */
+type Resource = ApiGatewayV2 | Postgres | Function | Bucket | Vpc | Secret;
+/**
+ * Function type for processing a specific resource type into environment variables.
+ *
+ * @template K - The specific resource type
+ * @param name - The resource name
+ * @param value - The resource value
+ * @returns Object mapping environment variable names to values
+ */
+type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
+//#endregion
+export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, Vpc, environmentCase, normalizeResourceEnv };