@8ms/helpers 2.3.2 → 2.3.4

package/.github/generate-exports.js

@@ -1,20 +1,15 @@
+
 import fs from 'fs';
 import path from 'path';
 import {fileURLToPath} from 'url';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname  = path.dirname(__filename);
-
-const projectRoot     = path.join(__dirname, '..');
-const packageJsonPath = path.join(projectRoot, 'package.json');
+const __dirname   = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, '..');
+const srcRoot     = path.join(projectRoot, 'src');
+const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
 
-// Read package.json
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const excludeDirs = new Set(['node_modules', 'scripts', 'jest', 'src', '.git', '.github', '.idea']);
 
-// Directories to exclude from scanning
-const excludeDirs = ['node_modules', 'scripts', 'jest', 'src', '.git', '.github', '.idea'];
-
-// Build exports object
 const exports = {
 	'.': {
 		types:   './index.d.ts',
@@ -24,55 +19,51 @@ const exports = {
 	}
 };
 
-// Recursively find all directories with index.js files
-function findIndexDirs(baseDir, relativePath = '')
-{
-	const entries = fs.readdirSync(baseDir, {withFileTypes: true});
+const importExportRegex = /((?:import|export)\s+(?:type\s+)?(?:[\s\S]*?from\s+)?['"])(\.{1,2}\/[^'"]+?)(['"])/g;
 
-	for(const entry of entries)
+function scan(baseDir, relativePath = '')
+{
+	for(const entry of fs.readdirSync(baseDir, {withFileTypes: true}))
 	{
-		if(!entry.isDirectory() || excludeDirs.includes(entry.name) || entry.name.startsWith('.'))
-		{
-			continue;
-		}
-
-		const fullPath = path.join(baseDir, entry.name);
+		const fullPath       = path.join(baseDir, entry.name);
 		const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-		const indexJsPath = path.join(fullPath, 'index.js');
 
-		// If this directory has an index.js, add it to exports
-		if(fs.existsSync(indexJsPath))
+		if(entry.isDirectory())
 		{
-			const exportConfig = {
-				types:   `./${newRelativePath}/index.d.ts`,
-				import:  `./${newRelativePath}/index.js`,
-				require: `./${newRelativePath}/index.js`,
-				default: `./${newRelativePath}/index.js`
-			};
+			if(excludeDirs.has(entry.name) || entry.name.startsWith('.')) continue;
 
-			// Add both the directory path and explicit index.js path
-			exports[`./${newRelativePath}`]          = exportConfig;
-			exports[`./${newRelativePath}/index.js`] = exportConfig;
+			if(fs.existsSync(path.join(fullPath, 'index.js')))
+			{
+				const jsPath = `./${newRelativePath}/index.js`;
+				const config = {types: `./${newRelativePath}/index.d.ts`, import: jsPath, require: jsPath, default: jsPath};
 
-			// Also add .d.ts mapping for TypeScript
-			exports[`./${newRelativePath}/index.d.ts`] = {
-				types:   `./${newRelativePath}/index.d.ts`,
-				default: `./${newRelativePath}/index.d.ts`
-			};
-		}
+				exports[`./${newRelativePath}`]            = config;
+				exports[`./${newRelativePath}/index.js`]  = config;
+				exports[`./${newRelativePath}/index.d.ts`] = {types: config.types, default: config.types};
+			}
 
-		// Recursively scan subdirectories
-		findIndexDirs(fullPath, newRelativePath);
+			scan(fullPath, newRelativePath);
+		}
+		else if(entry.isFile() && !entry.name.endsWith('.d.ts') && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')))
+		{
+			const original = fs.readFileSync(fullPath, 'utf8');
+			const updated  = original.replace(importExportRegex, (match, prefix, specifier, suffix) =>
+				path.extname(specifier) ? match : `${prefix}${specifier}.js${suffix}`
+			);
+
+			if(updated !== original)
+			{
+				fs.writeFileSync(fullPath, updated, 'utf8');
+				console.log(`Fixed extensions in: ${path.relative(projectRoot, fullPath)}`);
+			}
+		}
 	}
 }
 
-// Start scanning from project root
-findIndexDirs(projectRoot);
+scan(projectRoot);
+scan(srcRoot);
 
-// Update package.json with new exports
 packageJson.exports = exports;
-
-// Write back to package.json
-fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, '\t') + '\n', 'utf8');
+fs.writeFileSync(path.join(projectRoot, 'package.json'), JSON.stringify(packageJson, null, '\t') + '\n', 'utf8');
 
 console.log(`Generated exports for ${Object.keys(exports).length} entries`);

package/api/ApiResponseClass.js

@@ -1,16 +1,16 @@
 import { defaultTo } from "../util";
-import { ApiState } from "./api";
+import { apiState } from "./api";
 /**
  * Class version of the API to enable quicker instances.
  */
 export class ApiResponseClass {
-    state = ApiState.IDLE;
+    state = apiState.IDLE;
     body = null;
     error = null;
     constructor({ body, error, state } = {}) {
         this.body = body || null;
         this.error = error || null;
-        this.state = state || ApiState.IDLE;
+        this.state = state || apiState.IDLE;
         return this;
     }
     fromJson = (input) => {
@@ -39,34 +39,34 @@ export class ApiResponseClass {
         return this.state;
     };
     isError = () => {
-        return this.state === ApiState.ERROR;
+        return this.state === apiState.ERROR;
     };
     isIdle = () => {
-        return this.state === ApiState.IDLE;
+        return this.state === apiState.IDLE;
     };
     isPending = () => {
-        return this.state === ApiState.PENDING;
+        return this.state === apiState.PENDING;
     };
     isSuccess = () => {
-        return this.state === ApiState.SUCCESS;
+        return this.state === apiState.SUCCESS;
     };
     setToIdle = () => {
-        this.state = ApiState.IDLE;
+        this.state = apiState.IDLE;
         return this;
     };
     setToPending = () => {
-        this.state = ApiState.PENDING;
+        this.state = apiState.PENDING;
         return this;
     };
     setToError = (error, body) => {
         this.body = body || null;
         this.error = error;
-        this.state = ApiState.ERROR;
+        this.state = apiState.ERROR;
         return this;
     };
     setToSuccess = (body) => {
         this.body = body;
-        this.state = ApiState.SUCCESS;
+        this.state = apiState.SUCCESS;
         return this;
     };
     setBody = (body) => {
@@ -87,7 +87,7 @@ export class ApiResponseClass {
             return new ApiResponseClass({ body: validatedBody, state: this.state });
         }
         catch (error) {
-            return new ApiResponseClass({ error, state: ApiState.ERROR });
+            return new ApiResponseClass({ error, state: apiState.ERROR });
         }
     };
 }

package/api/api.d.ts

@@ -1,5 +1,5 @@
 export { ApiResponseClass } from "./ApiResponseClass";
-export declare const ApiState: {
+export declare const apiState: {
     readonly CANCELLED: "CANCELLED";
     readonly ERROR: "ERROR";
     readonly IDLE: "IDLE";
@@ -7,7 +7,7 @@ export declare const ApiState: {
     readonly SUCCESS: "SUCCESS";
     readonly VALIDATION_ERROR: "VALIDATION_ERROR";
 };
-export type ApiState = typeof ApiState[keyof typeof ApiState];
+export type ApiState = typeof apiState[keyof typeof apiState];
 export type ApiResponse<T = any, E = any> = {
     body: T | null;
     error: E | null;

package/api/api.js

@@ -1,5 +1,5 @@
 export { ApiResponseClass } from "./ApiResponseClass";
-export const ApiState = {
+export const apiState = {
     CANCELLED: "CANCELLED",
     ERROR: "ERROR",
     IDLE: "IDLE",
@@ -10,6 +10,6 @@ export const ApiState = {
 export const defaultResponse = {
     body: null,
     error: null,
-    state: ApiState.IDLE,
+    state: apiState.IDLE,
 };
 export const unexpectedError = "An unexpected error occurred, please try again.";

package/api/functions.js

@@ -1,19 +1,19 @@
-import { ApiState } from "./api";
+import { apiState } from "./api";
 export const isCancelled = (apiResponse) => {
-    return ApiState.CANCELLED === apiResponse.state;
+    return apiState.CANCELLED === apiResponse.state;
 };
 export const isError = (apiResponse) => {
-    return ApiState.ERROR === apiResponse.state;
+    return apiState.ERROR === apiResponse.state;
 };
 export const isIdle = (apiResponse) => {
-    return ApiState.IDLE === apiResponse.state;
+    return apiState.IDLE === apiResponse.state;
 };
 export const isPending = (apiResponse) => {
-    return ApiState.PENDING === apiResponse.state;
+    return apiState.PENDING === apiResponse.state;
 };
 export const isSuccess = (apiResponse) => {
-    return ApiState.SUCCESS === apiResponse.state;
+    return apiState.SUCCESS === apiResponse.state;
 };
 export const isValidationError = (apiResponse) => {
-    return ApiState.VALIDATION_ERROR === apiResponse.state;
+    return apiState.VALIDATION_ERROR === apiResponse.state;
 };

package/brightData/serpApi/server/brightDataSerpApi.d.ts

@@ -1,4 +1,4 @@
-export declare const BrightDataSerpApiType: {
+export declare const brightDataSerpApiType: {
     readonly GOOGLE_FLIGHTS: "GOOGLE_FLIGHTS";
     readonly GOOGLE_HOTELS: "GOOGLE_HOTELS";
     readonly GOOGLE_LENS: "GOOGLE_LENS";
@@ -7,4 +7,4 @@ export declare const BrightDataSerpApiType: {
     readonly GOOGLE_SEARCH: "GOOGLE_SEARCH";
     readonly GOOGLE_TRENDS: "GOOGLE_TRENDS";
 };
-export type BrightDataSerpApiType = typeof BrightDataSerpApiType[keyof typeof BrightDataSerpApiType];
+export type BrightDataSerpApiType = typeof brightDataSerpApiType[keyof typeof brightDataSerpApiType];

package/brightData/serpApi/server/brightDataSerpApi.js

@@ -1,4 +1,4 @@
-export const BrightDataSerpApiType = {
+export const brightDataSerpApiType = {
     GOOGLE_FLIGHTS: "GOOGLE_FLIGHTS",
     GOOGLE_HOTELS: "GOOGLE_HOTELS",
     GOOGLE_LENS: "GOOGLE_LENS",

package/brightData/serpApi/server/getAsyncRequestId.js

@@ -1,6 +1,6 @@
 import { post } from "../../../axios";
 import { getCustomerId, getZone } from "../../server";
-import { BrightDataSerpApiType } from "../server";
+import { brightDataSerpApiType } from "../server";
 /**
  * Make an async request to the SERP API using the Bright Data proxy.
  * Returns a request ID used with getAsyncResults
@@ -14,7 +14,7 @@ export const getAsyncRequestId = async (auth, data = {}, type) => {
     const customerId = getCustomerId(auth);
     const zone = getZone(auth);
     switch (type) {
-        case BrightDataSerpApiType.GOOGLE_TRENDS:
+        case brightDataSerpApiType.GOOGLE_TRENDS:
             url = `https://api.brightdata.com/serp/trends?customer=${customerId}&zone=${zone}`;
             break;
         default:

package/brightData/webScraperIde/server/getRealtime.js

@@ -1,5 +1,5 @@
 import { get, post } from "../../../axios";
-import { ApiState } from "../../../api";
+import { apiState } from "../../../api";
 import { sleep } from "../../../util";
 /**
  * Depends on the Scraper setup!
@@ -17,8 +17,8 @@ export const getRealtime = async (auth, scraperId, data = {}) => {
     if (requestResponse.isSuccess()) {
         const responseId = requestResponse.getBodyDefaultTo(["response_id"], "");
         if ("" !== responseId) {
-            let state = ApiState.PENDING;
-            while (ApiState.PENDING === state) {
+            let state = apiState.PENDING;
+            while (apiState.PENDING === state) {
                 const resultUrl = `https://api.brightdata.com/dca/get_result?response_id=${responseId}`;
                 // Use fetch with the agent option to make an HTTP request through the proxy
                 // Replace <target_url> with the URL you want to request
@@ -30,10 +30,10 @@ export const getRealtime = async (auth, scraperId, data = {}) => {
                 if (resultResponse.isSuccess()) {
                     if (undefined !== resultResponse.body.pending &&
                         true === resultResponse.body.pending) {
-                        state = ApiState.PENDING;
+                        state = apiState.PENDING;
                     }
                     else {
-                        state = ApiState.SUCCESS;
+                        state = apiState.SUCCESS;
                         response = resultResponse.getBody();
                     }
                 }

package/crud/crud.d.ts

@@ -1,7 +1,7 @@
-export declare const CrudState: {
+export declare const crudState: {
     readonly CREATE: "CREATE";
     readonly READ: "READ";
     readonly UPDATE: "UPDATE";
     readonly DELETE: "DELETE";
 };
-export type CrudState = typeof CrudState[keyof typeof CrudState];
+export type CrudState = typeof crudState[keyof typeof crudState];

package/crud/crud.js

@@ -1,4 +1,4 @@
-export const CrudState = {
+export const crudState = {
     CREATE: "CREATE",
     READ: "READ",
     UPDATE: "UPDATE",

package/date/calculation.d.ts

@@ -1,5 +1,8 @@
 import { DateTime } from "luxon";
 import { InputDate, Timeframe } from "./date";
+/**
+ * Return unix timestamp in seconds.
+ */
 export declare const getUnix: (input?: InputDate) => number;
 /**
  * Assume the input is always UTC.

package/date/calculation.js

@@ -1,4 +1,7 @@
 import { DateTime, Interval } from "luxon";
+/**
+ * Return unix timestamp in seconds.
+ */
 export const getUnix = (input) => {
     return getLuxonDate(input)
         .toUnixInteger();

package/date/date.d.ts

@@ -19,7 +19,7 @@ export declare const defaultDateTime: "1901-01-01 00:00:00";
 /**
  * Used by Google Ads API.
  */
-export declare const Month: {
+export declare const month: {
     readonly JANUARY: "JANUARY";
     readonly FEBRUARY: "FEBRUARY";
     readonly MARCH: "MARCH";
@@ -33,4 +33,4 @@ export declare const Month: {
     readonly NOVEMBER: "NOVEMBER";
     readonly DECEMBER: "DECEMBER";
 };
-export type Month = typeof Month[keyof typeof Month];
+export type Month = typeof month[keyof typeof month];

package/date/date.js

@@ -4,7 +4,7 @@ export const defaultDateTime = "1901-01-01 00:00:00";
 /**
  * Used by Google Ads API.
  */
-export const Month = {
+export const month = {
     JANUARY: "JANUARY",
     FEBRUARY: "FEBRUARY",
     MARCH: "MARCH",

package/date/financialYear.d.ts

@@ -1,7 +1,7 @@
 import { Timeframe } from "./date";
 import { Interval } from "luxon";
 /**
- * Get the current financial year.
+ * Get the financial year based on an optional year.
  */
 export declare const getFinancialYear: (year?: number) => Timeframe;
 /**

package/date/financialYear.js

@@ -1,7 +1,7 @@
 import { getLuxonDate, getToday, getYesterday } from "./calculation";
 import { Interval } from "luxon";
 /**
- * Get the current financial year.
+ * Get the financial year based on an optional year.
  */
 export const getFinancialYear = (year) => {
     // Either use the current year or a specified year

package/environment/environment.d.ts

@@ -1,14 +1,14 @@
-export declare const Environment: {
+export declare const environment: {
     readonly DEVELOPMENT: "development";
     readonly STAGING: "staging";
     readonly PRODUCTION: "production";
 };
-export type Environment = typeof Environment[keyof typeof Environment];
-export declare const Platform: {
+export type Environment = typeof environment[keyof typeof environment];
+export declare const platform: {
     readonly AWS: "AWS";
     readonly VERCEL: "VERCEL";
 };
-export type Platform = typeof Platform[keyof typeof Platform];
+export type Platform = typeof platform[keyof typeof platform];
 /**
  * Determine the environment we're using.
  */

package/environment/environment.js

@@ -1,9 +1,9 @@
-export const Environment = {
+export const environment = {
     DEVELOPMENT: "development",
     STAGING: "staging",
     PRODUCTION: "production",
 };
-export const Platform = {
+export const platform = {
     AWS: "AWS",
     VERCEL: "VERCEL",
 };
@@ -34,22 +34,22 @@ export const getEnvironment = () => {
         .trim();
     switch (platformEnvironmentClean) {
         case "production":
-            response = Environment.PRODUCTION;
+            response = environment.PRODUCTION;
             break;
         case "demo":
         case "preview":
         case "staging":
-            response = Environment.STAGING;
+            response = environment.STAGING;
             break;
         default:
-            response = Environment.DEVELOPMENT;
+            response = environment.DEVELOPMENT;
     }
     return response;
 };
 /**
  * Check to see if we are working on AWS Lambda.
  */
-export const isAws = () => Platform.AWS === process.env["EMS_PLATFORM"];
+export const isAws = () => platform.AWS === process.env["EMS_PLATFORM"];
 export const isVercel = () => undefined !== process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_REF;
 /**
  * Some code should only run on the server side to protect the data.
@@ -58,9 +58,9 @@ export const isServer = typeof window === "undefined";
 /**
  * Check the environment currently running.
  */
-export const isDevelopment = () => Environment.DEVELOPMENT === getEnvironment();
-export const isStaging = () => Environment.STAGING === getEnvironment();
-export const isProduction = () => Environment.PRODUCTION === getEnvironment();
+export const isDevelopment = () => environment.DEVELOPMENT === getEnvironment();
+export const isStaging = () => environment.STAGING === getEnvironment();
+export const isProduction = () => environment.PRODUCTION === getEnvironment();
 /**
  * Check to see if we are developing locally or on the hosted platform.
  */

package/file/getFileKey.js

@@ -1,5 +1,5 @@
 import { DateTime } from "luxon";
-import { format } from "../date";
+import { getYmdString } from "../date";
 /**
  * Create a file key from the inputs so it can handle objects/number/etc.
  */
@@ -13,7 +13,7 @@ export const getFileKey = (inputs) => {
             response += inputs[i];
         }
         else if (inputs[i] instanceof Date || inputs[i] instanceof DateTime) {
-            response += format(inputs[i], "YYYY-MM-DD");
+            response += getYmdString(inputs[i]);
         }
         else {
             response += JSON.stringify(inputs[i]);

package/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod/v4";
-export declare const Network: {
+export declare const network: {
     readonly GOOGLE_SEARCH_ONLY: 2;
     readonly GOOGLE_SEARCH_AND_PARTNERS: 3;
 };
-export type Network = typeof Network[keyof typeof Network];
+export type Network = typeof network[keyof typeof network];
 export declare const requestSchema: z.ZodObject<{
     countries: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     customerId: z.ZodOptional<z.ZodString>;

package/googleAds/keywordPlanner/server/googleAdsKeywordPlanner.js

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-export const Network = {
+export const network = {
     GOOGLE_SEARCH_ONLY: 2,
     GOOGLE_SEARCH_AND_PARTNERS: 3,
 };
@@ -31,7 +31,7 @@ export const defaultRequest = {
     customerId: "",
     historicalMetricsOptions: null,
     includeAdultKeywords: false,
-    keywordPlanNetwork: Network.GOOGLE_SEARCH_ONLY,
+    keywordPlanNetwork: network.GOOGLE_SEARCH_ONLY,
     queries: [],
     language: null,
 };

package/googleAds/server/GoogleAdsNamespace.js

@@ -21,11 +21,10 @@ export class GoogleAdsNamespace extends BaseNamespace {
     };
     getCustomer = async (customerId) => {
         await this.ensureInit();
-        const customer = this.client.Customer({
+        return this.client.Customer({
             customer_id: customerId,
             login_customer_id: this.mccAccountId,
             refresh_token: this.refreshToken,
         });
-        return customer;
     };
 }

package/googlePageSpeed/server/GooglePageSpeedNamespace.d.ts

@@ -7,5 +7,5 @@ export declare class GooglePageSpeedNamespace extends BaseNamespace {
     client: boolean;
     config: GooglePageSpeedConfig;
     ensureInit: () => Promise<void>;
-    getReport: (url: string, category?: Category, strategy?: Strategy) => Promise<any>;
+    getReport: (url: string, inputCategory?: Category, inputStrategy?: Strategy) => Promise<any>;
 }

package/googlePageSpeed/server/GooglePageSpeedNamespace.js

@@ -1,5 +1,5 @@
 import { BaseNamespace } from "../../_class";
-import { Category, Strategy } from "./";
+import { category, strategy } from "./";
 import { get } from "../../axios";
 /**
  * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
@@ -16,8 +16,8 @@ export class GooglePageSpeedNamespace extends BaseNamespace {
             }
         }
     };
-    getReport = async (url, category = Category.PERFORMANCE, strategy = Strategy.MOBILE) => {
-        const requestUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${url}&strategy=${strategy}&category=${category}&key=${this.config.apiKey}`;
+    getReport = async (url, inputCategory = category.PERFORMANCE, inputStrategy = strategy.MOBILE) => {
+        const requestUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${url}&strategy=${inputStrategy}&category=${inputCategory}&key=${this.config.apiKey}`;
         const apiResponse = await get(requestUrl);
         if (apiResponse.isSuccess()) {
             return apiResponse.getBody();

package/googlePageSpeed/server/googlePageSpeed.d.ts

@@ -3,17 +3,17 @@ export type GooglePageSpeedConfig = {
     apiKey: string;
 };
 export declare const googlePageSpeedClient: (key?: string, config?: GooglePageSpeedConfig, vaultId?: string, itemId?: string) => Promise<GooglePageSpeedNamespace>;
-export declare const Category: {
+export declare const category: {
     readonly CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED";
     readonly ACCESSIBILITY: "ACCESSIBILITY";
     readonly BEST_PRACTICES: "BEST_PRACTICES";
     readonly PERFORMANCE: "PERFORMANCE";
     readonly SEO: "SEO";
 };
-export type Category = typeof Category[keyof typeof Category];
-export declare const Strategy: {
+export type Category = typeof category[keyof typeof category];
+export declare const strategy: {
     readonly STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED";
     readonly DESKTOP: "DESKTOP";
     readonly MOBILE: "MOBILE";
 };
-export type Strategy = typeof Strategy[keyof typeof Strategy];
+export type Strategy = typeof strategy[keyof typeof strategy];

package/googlePageSpeed/server/googlePageSpeed.js

@@ -24,14 +24,14 @@ export const googlePageSpeedClient = async (key = "default", config, vaultId, it
     googlePageSpeedNamespaces.set(key, namespace);
     return namespace;
 };
-export const Category = {
+export const category = {
     CATEGORY_UNSPECIFIED: "CATEGORY_UNSPECIFIED",
     ACCESSIBILITY: "ACCESSIBILITY",
     BEST_PRACTICES: "BEST_PRACTICES",
     PERFORMANCE: "PERFORMANCE",
     SEO: "SEO",
 };
-export const Strategy = {
+export const strategy = {
     STRATEGY_UNSPECIFIED: "STRATEGY_UNSPECIFIED",
     DESKTOP: "DESKTOP",
     MOBILE: "MOBILE",

package/inngest/inngest.d.ts

@@ -1,7 +1,7 @@
-export declare const InngestState: {
+export declare const inngestState: {
     RUNNING: string;
     COMPLETED: string;
     FAILED: string;
     CANCELLED: string;
 };
-export type InngestState = typeof InngestState[keyof typeof InngestState];
+export type InngestState = typeof inngestState[keyof typeof inngestState];

package/inngest/inngest.js

@@ -1,4 +1,4 @@
-export const InngestState = {
+export const inngestState = {
     RUNNING: "Running",
     COMPLETED: "Completed",
     FAILED: "Failed",

package/littleWarden/server/littleWarden.d.ts

@@ -3,12 +3,12 @@ export type LittleWardenConfig = {
     apiKey: string;
 };
 export declare const littleWardenClient: (key?: string, config?: LittleWardenConfig, vaultId?: string, itemId?: string) => Promise<LittleWardenNamespace>;
-export declare const LittleWardenState: {
+export declare const littleWardenState: {
     readonly ALL_GOOD: "all_good";
     readonly DANGER: "danger";
     readonly WARNING: "warning";
 };
-export type LittleWardenState = typeof LittleWardenState[keyof typeof LittleWardenState];
+export type LittleWardenState = typeof littleWardenState[keyof typeof littleWardenState];
 /**
  * Check if the field is All Good.
  */