@smooai/config 2.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,430 @@
+<!-- Improved compatibility of back to top link: See: https://github.com/othneildrew/Best-README-Template/pull/73 -->
+
+<a name="readme-top"></a>
+
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+  <a href="https://smoo.ai">
+    <img src="images/logo.png" alt="SmooAI Logo" />
+  </a>
+</div>
+
+<!-- ABOUT THE PROJECT -->
+
+## About SmooAI
+
+SmooAI is an AI-powered platform for helping businesses multiply their customer, employee, and developer experience.
+
+Learn more on [smoo.ai](https://smoo.ai)
+
+## SmooAI Packages
+
+Check out other SmooAI packages at [smoo.ai/open-source](https://smoo.ai/open-source)
+
+## About @smooai/config
+
+**Type-safe configuration management for every layer of your stack** - Define configuration schemas once, validate everywhere, and manage public settings, secrets, and feature flags across TypeScript, Python, Rust, and Go.
+
+![NPM Version](https://img.shields.io/npm/v/%40smooai%2Fconfig?style=for-the-badge)
+![NPM Downloads](https://img.shields.io/npm/dw/%40smooai%2Fconfig?style=for-the-badge)
+![NPM Last Update](https://img.shields.io/npm/last-update/%40smooai%2Fconfig?style=for-the-badge)
+
+![GitHub License](https://img.shields.io/github/license/SmooAI/config?style=for-the-badge)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/SmooAI/config/release.yml?style=for-the-badge)
+![GitHub Repo stars](https://img.shields.io/github/stars/SmooAI/config?style=for-the-badge)
+
+### Why @smooai/config?
+
+Ever scattered configuration values across environment variables, JSON files, and hardcoded strings? Or struggled to keep configuration consistent across microservices written in different languages? Traditional config management gives you the values, but not the safety.
+
+**@smooai/config provides:**
+
+- **Three configuration tiers** - Separate public config, secrets, and feature flags with distinct schemas
+- **Schema-agnostic validation** - Works with Zod, Valibot, ArkType, Effect Schema, or any StandardSchema-compliant library
+- **Type-safe keys** - Automatic camelCase-to-UPPER_SNAKE_CASE mapping with full TypeScript inference
+- **JSON Schema serialization** - Convert any schema to JSON Schema for cross-language interoperability
+- **Runtime client** - Fetch configuration from a centralized config server with local caching
+- **Multi-language support** - Native implementations in TypeScript, Python, Rust, and Go
+
+### Install
+
+#### TypeScript / JavaScript
+
+```sh
+pnpm add @smooai/config
+```
+
+#### Python
+
+```sh
+pip install smooai-config
+```
+
+or with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv add smooai-config
+```
+
+#### Rust
+
+```toml
+[dependencies]
+smooai-config = { git = "https://github.com/SmooAI/config", package = "smooai-config" }
+```
+
+#### Go
+
+```sh
+go get github.com/SmooAI/config/go/config
+```
+
+## Usage
+
+### TypeScript - Define Configuration Schemas
+
+Use any StandardSchema-compliant validation library to define your configuration:
+
+```typescript
+import { defineConfig, StringSchema, BooleanSchema, NumberSchema } from '@smooai/config';
+import { z } from 'zod';
+
+const config = defineConfig({
+    publicConfigSchema: {
+        apiUrl: z.string().url(),
+        maxRetries: NumberSchema,
+        enableDebug: BooleanSchema,
+    },
+    secretConfigSchema: {
+        databaseUrl: z.string().url(),
+        apiKey: StringSchema,
+    },
+    featureFlagSchema: {
+        enableNewUI: BooleanSchema,
+        betaFeatures: BooleanSchema,
+    },
+});
+```
+
+Supports Zod, Valibot, ArkType, Effect Schema, and built-in schema types - see [SCHEMA_USAGE.md](SCHEMA_USAGE.md) for examples with each library.
+
+### Python - Define and Fetch Configuration
+
+```python
+from pydantic import BaseModel
+from smooai_config import define_config, ConfigTier
+from smooai_config.client import ConfigClient
+
+# Define schemas using Pydantic models
+class PublicConfig(BaseModel):
+    api_url: str = "https://api.example.com"
+    max_retries: int = 3
+
+class SecretConfig(BaseModel):
+    database_url: str
+    api_key: str
+
+config = define_config(
+    public=PublicConfig,
+    secret=SecretConfig,
+)
+
+# Fetch values at runtime
+with ConfigClient(
+    base_url="https://config.smooai.dev",
+    api_key="your-api-key",
+    org_id="your-org-id",
+) as client:
+    value = client.get_value("API_URL", environment="production")
+    all_values = client.get_all_values(environment="production")
+```
+
+### Rust - Define and Fetch Configuration
+
+```rust
+use smooai_config::{define_config, ConfigTier};
+use smooai_config::client::ConfigClient;
+
+// Define configuration tiers
+let config = define_config(
+    Some(vec![("api_url", "https://api.example.com")]),
+    Some(vec![("database_url", "postgres://...")]),
+    None,
+);
+
+// Fetch values at runtime
+let client = ConfigClient::new(
+    "https://config.smooai.dev",
+    "your-api-key",
+    "your-org-id",
+);
+let value = client.get_value("API_URL", Some("production")).await?;
+```
+
+### Go - Define and Fetch Configuration
+
+```go
+import "github.com/SmooAI/config/go/config"
+
+// Define configuration
+cfg := config.DefineConfig(
+    map[string]interface{}{"apiUrl": "https://api.example.com"},
+    map[string]interface{}{"databaseUrl": "postgres://..."},
+    nil,
+)
+
+// Fetch values at runtime
+client := config.NewConfigClient(
+    "https://config.smooai.dev",
+    "your-api-key",
+    "your-org-id",
+)
+defer client.Close()
+value, err := client.GetValue("API_URL", "production")
+allValues, err := client.GetAllValues("production")
+```
+
+## SDK Runtime Client
+
+All language implementations include a runtime client for fetching configuration values from the Smoo AI config server. Each client supports local caching and environment variable configuration.
+
+### Environment Variables
+
+All clients read from the same set of environment variables:
+
+| Variable                | Description                                            | Required |
+| ----------------------- | ------------------------------------------------------ | -------- |
+| `SMOOAI_CONFIG_API_URL` | Base URL of the config API                             | Yes      |
+| `SMOOAI_CONFIG_API_KEY` | Bearer token for authentication                        | Yes      |
+| `SMOOAI_CONFIG_ORG_ID`  | Organization ID                                        | Yes      |
+| `SMOOAI_CONFIG_ENV`     | Default environment name (defaults to `"development"`) | No       |
+
+Set these in your environment and the client will use them automatically:
+
+```sh
+export SMOOAI_CONFIG_API_URL="https://config.smooai.dev"
+export SMOOAI_CONFIG_API_KEY="your-api-key"
+export SMOOAI_CONFIG_ORG_ID="your-org-id"
+export SMOOAI_CONFIG_ENV="production"
+```
+
+### TypeScript SDK Client
+
+The TypeScript client works in any JavaScript runtime (Node.js, browsers, edge runtimes):
+
+```typescript
+import { ConfigClient } from '@smooai/config/platform/client';
+
+// Option 1: Use environment variables (zero-config)
+const client = new ConfigClient();
+
+// Option 2: Explicit configuration (overrides env vars)
+const client = new ConfigClient({
+    baseUrl: 'https://config.smooai.dev',
+    apiKey: 'your-api-key',
+    orgId: 'your-org-id',
+    environment: 'production',
+});
+
+// Fetch a single value (uses default environment)
+const apiUrl = await client.getValue('API_URL');
+
+// Fetch a value for a specific environment
+const stagingUrl = await client.getValue('API_URL', 'staging');
+
+// Fetch all values
+const allValues = await client.getAllValues();
+
+// Clear the local cache
+client.invalidateCache();
+```
+
+### React Hooks
+
+For React applications, use the built-in hooks with `ConfigProvider`:
+
+```tsx
+import { ConfigProvider, usePublicConfig, useSecretConfig, useFeatureFlag } from '@smooai/config/react';
+
+// Wrap your app with ConfigProvider
+function App() {
+    return (
+        <ConfigProvider baseUrl="https://config.smooai.dev" apiKey="your-api-key" orgId="your-org-id" environment="production">
+            <MyComponent />
+        </ConfigProvider>
+    );
+}
+
+// Use hooks in any child component
+function MyComponent() {
+    const { value: apiUrl, isLoading, error } = usePublicConfig<string>('API_URL');
+    const { value: dbUrl } = useSecretConfig<string>('DATABASE_URL');
+    const { value: enableNewUI, refetch } = useFeatureFlag<boolean>('ENABLE_NEW_UI');
+
+    if (isLoading) return <div>Loading...</div>;
+    if (error) return <div>Error: {error.message}</div>;
+
+    return <div>API URL: {apiUrl}</div>;
+}
+```
+
+### Python SDK Client
+
+```python
+from smooai_config.client import ConfigClient
+
+# Option 1: Use environment variables (zero-config)
+with ConfigClient() as client:
+    value = client.get_value("API_URL")
+    all_values = client.get_all_values()
+
+# Option 2: Explicit configuration
+with ConfigClient(
+    base_url="https://config.smooai.dev",
+    api_key="your-api-key",
+    org_id="your-org-id",
+    environment="production",
+) as client:
+    value = client.get_value("API_URL")
+    value = client.get_value("API_URL", environment="staging")  # Override environment
+```
+
+### Rust SDK Client
+
+```rust
+use smooai_config::client::ConfigClient;
+
+// Option 1: Use environment variables (zero-config)
+let mut client = ConfigClient::from_env();
+
+// Option 2: Explicit configuration
+let mut client = ConfigClient::new(
+    "https://config.smooai.dev",
+    "your-api-key",
+    "your-org-id",
+);
+
+// Option 3: Explicit with default environment
+let mut client = ConfigClient::with_environment(
+    "https://config.smooai.dev",
+    "your-api-key",
+    "your-org-id",
+    "production",
+);
+
+// Fetch values (None uses default environment)
+let value = client.get_value("API_URL", None).await?;
+let value = client.get_value("API_URL", Some("staging")).await?;
+let all = client.get_all_values(None).await?;
+```
+
+### Go SDK Client
+
+```go
+import "github.com/SmooAI/config/go/config"
+
+// Option 1: Use environment variables (zero-config)
+client := config.NewConfigClientFromEnv()
+defer client.Close()
+
+// Option 2: Explicit configuration (empty strings fall back to env vars)
+client := config.NewConfigClient(
+    "https://config.smooai.dev",
+    "your-api-key",
+    "your-org-id",
+)
+defer client.Close()
+
+// Fetch values (empty string uses default environment)
+value, err := client.GetValue("API_URL", "")
+value, err := client.GetValue("API_URL", "staging")
+allValues, err := client.GetAllValues("")
+```
+
+## Configuration Tiers
+
+| Tier              | Purpose                 | Examples                                 |
+| ----------------- | ----------------------- | ---------------------------------------- |
+| **Public**        | Client-visible settings | API URLs, feature toggles, UI config     |
+| **Secret**        | Server-side only        | Database URLs, API keys, JWT secrets     |
+| **Feature Flags** | Runtime toggles         | A/B tests, gradual rollouts, beta access |
+
+Each tier gets its own schema, validation, and JSON Schema output for cross-language consumption.
+
+## Development
+
+### Prerequisites
+
+- Node.js 22+, pnpm 10+
+- Python 3.13+ with uv
+- Rust toolchain (rustup)
+- Go 1.22+
+
+### Commands
+
+```sh
+pnpm install               # Install dependencies
+pnpm build                 # Build all packages (TS, Python, Rust, Go)
+pnpm test                  # Run all tests (Vitest, pytest, cargo test, go test)
+pnpm lint                  # Lint all code (oxlint, ruff, clippy, go vet)
+pnpm format                # Format all code (oxfmt, ruff, cargo fmt, gofmt)
+pnpm typecheck             # Type check (tsc, basedpyright, cargo check)
+pnpm check-all             # Full CI parity check
+```
+
+### Built With
+
+- **TypeScript** - Core implementation with StandardSchema support
+- **Python** - Pydantic-based schemas with httpx runtime client
+- **Rust** - Serde-based schemas with reqwest async client
+- **Go** - Native schemas with net/http client and local caching
+- [StandardSchema](https://github.com/standard-schema/standard-schema) - Schema-agnostic validation
+- [Zod](https://zod.dev/), [Valibot](https://valibot.dev/), [ArkType](https://arktype.io/), [Effect](https://effect.website/) - Supported validation libraries
+
+## Contributing
+
+Contributions are welcome! This project uses [changesets](https://github.com/changesets/changesets) to manage versions and releases.
+
+### Development Workflow
+
+1. Fork the repository
+2. Create your branch (`git checkout -b amazing-feature`)
+3. Make your changes
+4. Add a changeset to document your changes:
+
+    ```sh
+    pnpm changeset
+    ```
+
+    This will prompt you to:
+    - Choose the type of version bump (patch, minor, or major)
+    - Provide a description of the changes
+
+5. Commit your changes (`git commit -m 'Add some amazing feature'`)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+### Pull Request Guidelines
+
+- Reference any related issues in your PR description
+
+The maintainers will review your PR and may request changes before merging.
+
+<!-- CONTACT -->
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Contact
+
+Brent Rager
+
+- [Email](mailto:brent@smoo.ai)
+- [LinkedIn](https://www.linkedin.com/in/brentrager/)
+- [BlueSky](https://bsky.app/profile/brentragertech.bsky.social)
+- [TikTok](https://www.tiktok.com/@brentragertech)
+- [Instagram](https://www.instagram.com/brentragertech/)
+
+Smoo Github: [https://github.com/SmooAI](https://github.com/SmooAI)
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>

package/dist/chunk-3SU3SMKN.mjs

@@ -0,0 +1,73 @@
+// src/utils/index.ts
+import createEsmUtils from "esm-utils";
+function initEsmUtils() {
+  if (!global.__dirname || !global.__filename) {
+    const { __dirname, __filename } = import.meta.url ? createEsmUtils({ url: import.meta.url, resolve: import.meta.resolve }) : { __dirname: "", __filename: "" };
+    global.__dirname = global.__dirname ? global.__dirname : __dirname;
+    global.__filename = global.__filename ? global.__filename : __filename;
+  }
+}
+function isEmpty(obj) {
+  for (const prop in obj) {
+    if (Object.hasOwn(obj, prop)) {
+      return false;
+    }
+  }
+  return true;
+}
+var envToUse = () => !isEmpty(process?.env) ? process.env : import.meta.env;
+function isPlainObject(obj) {
+  return !!obj && typeof obj === "object" && !Array.isArray(obj);
+}
+var SmooaiConfigError = class extends Error {
+  constructor(message, options) {
+    super(`[Smooai Config] ${message}`, options);
+  }
+};
+function snakecase(input) {
+  if (/^[A-Z0-9]+(?:_[A-Z0-9]+)*$/.test(input)) {
+    return input;
+  }
+  let out = "";
+  const len = input.length;
+  for (let i = 0; i < len; i++) {
+    const ch = input[i];
+    if (ch === "_" || ch === " ") continue;
+    const code = input.charCodeAt(i);
+    const isUpper = code >= 65 && code <= 90;
+    const isLower = code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+    if (isUpper) {
+      if (i > 0) {
+        const prev = input.charCodeAt(i - 1);
+        const prevIsLower = prev >= 97 && prev <= 122;
+        const next = i + 1 < len ? input.charCodeAt(i + 1) : NaN;
+        const nextIsLower = next >= 97 && next <= 122;
+        if (prevIsLower || nextIsLower) {
+          out += "_";
+        }
+      }
+      out += ch;
+    } else if (isLower) {
+      out += String.fromCharCode(code - 32);
+    } else if (isDigit) {
+      out += ch;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function convertKeyToUpperSnakeCase(key) {
+  return snakecase(key).toUpperCase();
+}
+
+export {
+  initEsmUtils,
+  envToUse,
+  isPlainObject,
+  SmooaiConfigError,
+  snakecase,
+  convertKeyToUpperSnakeCase
+};
+//# sourceMappingURL=chunk-3SU3SMKN.mjs.map

package/dist/chunk-3SU3SMKN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- ok */\nimport createEsmUtils from 'esm-utils';\n\n/**\n * Initialize global __dirname and __filename if not already set.\n */\nexport function initEsmUtils() {\n    if (!global.__dirname || !global.__filename) {\n        const { __dirname, __filename } = import.meta.url\n            ? createEsmUtils({ url: import.meta.url, resolve: import.meta.resolve } as any)\n            : { __dirname: '', __filename: '' };\n        global.__dirname = global.__dirname ? global.__dirname : __dirname;\n        global.__filename = global.__filename ? global.__filename : __filename;\n    }\n}\n\n/**\n * Check if an object is empty.\n */\nfunction isEmpty(obj: any): boolean {\n    for (const prop in obj) {\n        if (Object.hasOwn(obj, prop)) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * Get the environment variables. Works in Node and Various React Runtimes.\n */\nexport const envToUse = (): NodeJS.ProcessEnv => (!isEmpty(process?.env) ? process.env : (import.meta as unknown as { env: NodeJS.ProcessEnv }).env);\n\n/**\n * Minimal utility to detect an object (excludes arrays).\n */\nexport function isPlainObject(obj: unknown): obj is Record<string, unknown> {\n    return !!obj && typeof obj === 'object' && !Array.isArray(obj);\n}\n\nexport class SmooaiConfigError extends Error {\n    constructor(message: string, options?: ErrorOptions) {\n        super(`[Smooai Config] ${message}`, options);\n    }\n}\n\n// ——— helper: single-char step, always recursing into SnakeCase<> ———\ntype _SnakeCaseChar<S extends string> = S extends `${infer First}${infer Rest}`\n    ? First extends '_' | ' '\n        ? SnakeCase<Rest> // drop \"_\" or \" \"\n        : Rest extends Uncapitalize<Rest>\n          ? `${Lowercase<First>}${SnakeCase<Rest>}` // next is lower/non-letter → no underscore\n          : First extends Lowercase<First>\n            ? `${Lowercase<First>}_${SnakeCase<Rest>}` // lower→upper → underscore\n            : `${Lowercase<First>}${SnakeCase<Rest>}` // upper→upper → no underscore\n    : S; // empty or single character\n\n// ——— your public SnakeCase<> with 3-char look-ahead for acronyms ———\nexport type SnakeCase<S extends string> =\n    // 1⃣ Acronym boundary: Upper + Upper + lower  (e.g. \"IKey\" → \"i_key\")\n    S extends `${infer A}${infer B}${infer C}${infer Rest}`\n        ? A extends Uppercase<A>\n            ? B extends Uppercase<B>\n                ? C extends Lowercase<C>\n                    ? `${Lowercase<A>}_${SnakeCase<`${B}${C}${Rest}`>}`\n                    : _SnakeCaseChar<S>\n                : _SnakeCaseChar<S>\n            : _SnakeCaseChar<S>\n        : // 2⃣ If we don’t even have 3 chars to peek, fall back to the single-char step\n          _SnakeCaseChar<S>;\n\nexport type UpperSnakeCase<S extends string> =\n    S extends Uppercase<S>\n        ? S extends `${string} ${string}`\n            ? // if it had a space, rerun SnakeCase to turn that into \" \"\n              Uppercase<SnakeCase<S>>\n            : S\n        : Uppercase<SnakeCase<S>>;\n\nexport type UnionToUpperSnake<U> = U extends string ? UpperSnakeCase<U> : never;\n\n/**\n * One-pass, no-regex UPPER_SNAKE_CASE converter.\n * - Early exit if already UPPER_SNAKE_CASE.\n * - Drops spaces/underscores.\n * - Splits on  lower→Upper  and  Acronym→Word\n */\nexport function snakecase(input: string): string {\n    // Early return if it’s already UPPER_SNAKE_CASE\n    if (/^[A-Z0-9]+(?:_[A-Z0-9]+)*$/.test(input)) {\n        return input;\n    }\n\n    let out = '';\n    const len = input.length;\n\n    for (let i = 0; i < len; i++) {\n        const ch = input[i];\n        if (ch === '_' || ch === ' ') continue; // drop underscores/spaces\n\n        const code = input.charCodeAt(i);\n        const isUpper = code >= 65 && code <= 90; // A–Z\n        const isLower = code >= 97 && code <= 122; // a–z\n        const isDigit = code >= 48 && code <= 57; // 0–9\n\n        if (isUpper) {\n            // split on lower→upper or acronym→word\n            if (i > 0) {\n                const prev = input.charCodeAt(i - 1);\n                const prevIsLower = prev >= 97 && prev <= 122;\n                const next = i + 1 < len ? input.charCodeAt(i + 1) : NaN;\n                const nextIsLower = next >= 97 && next <= 122;\n                if (prevIsLower || nextIsLower) {\n                    out += '_';\n                }\n            }\n            out += ch; // keep uppercase\n        } else if (isLower) {\n            // lowercase → uppercase\n            out += String.fromCharCode(code - 32);\n        } else if (isDigit) {\n            // digit → append as-is\n            out += ch;\n        } else {\n            // any other character: append or drop as you see fit\n            out += ch;\n        }\n    }\n\n    return out;\n}\n\nexport function convertKeyToUpperSnakeCase(key: string): string {\n    return snakecase(key).toUpperCase();\n}\n"],"mappings":";AACA,OAAO,oBAAoB;AAKpB,SAAS,eAAe;AAC3B,MAAI,CAAC,OAAO,aAAa,CAAC,OAAO,YAAY;AACzC,UAAM,EAAE,WAAW,WAAW,IAAI,YAAY,MACxC,eAAe,EAAE,KAAK,YAAY,KAAK,SAAS,YAAY,QAAQ,CAAQ,IAC5E,EAAE,WAAW,IAAI,YAAY,GAAG;AACtC,WAAO,YAAY,OAAO,YAAY,OAAO,YAAY;AACzD,WAAO,aAAa,OAAO,aAAa,OAAO,aAAa;AAAA,EAChE;AACJ;AAKA,SAAS,QAAQ,KAAmB;AAChC,aAAW,QAAQ,KAAK;AACpB,QAAI,OAAO,OAAO,KAAK,IAAI,GAAG;AAC1B,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AACX;AAKO,IAAM,WAAW,MAA0B,CAAC,QAAQ,SAAS,GAAG,IAAI,QAAQ,MAAO,YAAsD;AAKzI,SAAS,cAAc,KAA8C;AACxE,SAAO,CAAC,CAAC,OAAO,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,GAAG;AACjE;AAEO,IAAM,oBAAN,cAAgC,MAAM;AAAA,EACzC,YAAY,SAAiB,SAAwB;AACjD,UAAM,mBAAmB,OAAO,IAAI,OAAO;AAAA,EAC/C;AACJ;AA2CO,SAAS,UAAU,OAAuB;AAE7C,MAAI,6BAA6B,KAAK,KAAK,GAAG;AAC1C,WAAO;AAAA,EACX;AAEA,MAAI,MAAM;AACV,QAAM,MAAM,MAAM;AAElB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC1B,UAAM,KAAK,MAAM,CAAC;AAClB,QAAI,OAAO,OAAO,OAAO,IAAK;AAE9B,UAAM,OAAO,MAAM,WAAW,CAAC;AAC/B,UAAM,UAAU,QAAQ,MAAM,QAAQ;AACtC,UAAM,UAAU,QAAQ,MAAM,QAAQ;AACtC,UAAM,UAAU,QAAQ,MAAM,QAAQ;AAEtC,QAAI,SAAS;AAET,UAAI,IAAI,GAAG;AACP,cAAM,OAAO,MAAM,WAAW,IAAI,CAAC;AACnC,cAAM,cAAc,QAAQ,MAAM,QAAQ;AAC1C,cAAM,OAAO,IAAI,IAAI,MAAM,MAAM,WAAW,IAAI,CAAC,IAAI;AACrD,cAAM,cAAc,QAAQ,MAAM,QAAQ;AAC1C,YAAI,eAAe,aAAa;AAC5B,iBAAO;AAAA,QACX;AAAA,MACJ;AACA,aAAO;AAAA,IACX,WAAW,SAAS;AAEhB,aAAO,OAAO,aAAa,OAAO,EAAE;AAAA,IACxC,WAAW,SAAS;AAEhB,aAAO;AAAA,IACX,OAAO;AAEH,aAAO;AAAA,IACX;AAAA,EACJ;AAEA,SAAO;AACX;AAEO,SAAS,2BAA2B,KAAqB;AAC5D,SAAO,UAAU,GAAG,EAAE,YAAY;AACtC;","names":[]}

package/dist/chunk-CASNDTCH.mjs

@@ -0,0 +1,12 @@
+// src/config/PublicConfigKey.ts
+var PublicConfigKey = {
+  ENV: "ENV",
+  IS_LOCAL: "IS_LOCAL",
+  REGION: "REGION",
+  CLOUD_PROVIDER: "CLOUD_PROVIDER"
+};
+
+export {
+  PublicConfigKey
+};
+//# sourceMappingURL=chunk-CASNDTCH.mjs.map

package/dist/chunk-CASNDTCH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/PublicConfigKey.ts"],"sourcesContent":["/**\n * Extendable enum representing public config keys.\n *\n * This class is used to define the public config keys that are available to the application.\n *\n * An example of public confg keys is configurable values that you don't mind being exposed to the user, like a public API key for accessing a headless CMS.\n *\n * @example\n * ```typescript\n * export class MyPublicConfigKey extends PublicConfigKey {\n *    static readonly MY_PUBLIC_API_KEY = 'MY_PUBLIC_API_KEY';\n * }\n */\nexport const PublicConfigKey = {\n    ENV: 'ENV',\n    IS_LOCAL: 'IS_LOCAL',\n    REGION: 'REGION',\n    CLOUD_PROVIDER: 'CLOUD_PROVIDER',\n} as const;\n\nexport type PublicConfigKey = (typeof PublicConfigKey)[keyof typeof PublicConfigKey];\n"],"mappings":";AAaO,IAAM,kBAAkB;AAAA,EAC3B,KAAK;AAAA,EACL,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,gBAAgB;AACpB;","names":[]}