silgi 0.24.18 → 0.24.19

package/dist/_chunks/path.mjs

@@ -0,0 +1,62 @@
+import satisfies from 'semver/functions/satisfies.js';
+import { useSilgi } from 'silgi';
+import { version } from 'silgi/meta';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { getProperty } from 'dot-prop';
+import { relative, resolve } from 'pathe';
+
+const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
+function normalizeSemanticVersion(version) {
+  return version.replace(SEMANTIC_VERSION_RE, "");
+}
+const SILGI_VERSION_RE = /^v/g;
+async function checkSilgiCompatibility(constraints, silgi = useSilgi()) {
+  const issues = [];
+  if (constraints.silgi) {
+    const _silgiVersion = version.replace(SILGI_VERSION_RE, "");
+    if (!satisfies(normalizeSemanticVersion(_silgiVersion), constraints.silgi, { includePrerelease: true })) {
+      issues.push({
+        name: "silgi",
+        message: `Silgi version \`${constraints.silgi}\` is required but currently using \`${version}\``
+      });
+    }
+  }
+  await silgi.callHook("kit:compatibility", constraints, issues);
+  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
+  return issues;
+}
+function hasInstalledModule(moduleKey, silgi = useSilgi()) {
+  const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
+  return find?.installed ?? false;
+}
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+function resolveSilgiPath(path, silgiCLIOptions, base) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Invalid path: ${path}`);
+  }
+  path = _compilePathTemplate(path)(silgiCLIOptions);
+  for (const base2 in silgiCLIOptions.alias) {
+    if (path.startsWith(base2)) {
+      path = silgiCLIOptions.alias[base2] + path.slice(base2.length);
+    }
+  }
+  return resolve(base || silgiCLIOptions.srcDir, path);
+}
+function _compilePathTemplate(contents) {
+  return (params) => contents.replace(/\{\{ ?([\w.]+) ?\}\}/g, (_, match) => {
+    const val = getProperty(params, match);
+    if (!val) {
+      consola.warn(
+        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
+      );
+    }
+    return val || `${match}`;
+  });
+}
+
+export { checkSilgiCompatibility as c, hasInstalledModule as h, prettyPath as p, resolveSilgiPath as r };

package/dist/cli/dev.mjs

@@ -3,52 +3,15 @@ import { watch } from 'chokidar';
 import { defineCommand, runCommand } from 'citty';
 import consola from 'consola';
 import { join } from 'pathe';
-import { useSilgiCLI } from 'silgi';
+import { useSilgi, reloadScan, silgiClose } from 'silgi';
 import { version } from 'silgi/meta';
-import { a as silgiCLIIClose } from '../_chunks/routeRules.mjs';
 import { c as commonArgs, p as prepare } from './prepare.mjs';
-import 'unctx';
-import 'ufo';
-import './writeTypesAndFiles.mjs';
-import 'knitwork';
-import 'silgi/kit';
+import 'node:child_process';
 import 'node:fs';
-import 'node:fs/promises';
-import 'hookable';
-import 'silgi/runtime/meta';
-import 'unimport';
 import '@clack/prompts';
-import 'dotenv';
-import 'mlly';
 import 'dev-jiti';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'untyped';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import './types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
-import 'pathe/utils';
-import 'node:child_process';
 import 'picocolors';
-
-async function reloadScan(path, _stats) {
-  const silgi = useSilgiCLI();
-  await silgi.callHook("reload:scan", path, _stats);
-}
+import './env.mjs';
 
 const dev = defineCommand({
   meta: {
@@ -71,7 +34,7 @@ const dev = defineCommand({
     await runCommand(prepare, {
       rawArgs: ["--commands", "run", "--dev", "true"]
     });
-    const silgi = useSilgiCLI();
+    const silgi = useSilgi();
     silgi.options.watchOptions.ignored ??= [];
     silgi.options.watchOptions.ignoreInitial = true;
     if (Array.isArray(silgi.options.watchOptions.ignored)) {
@@ -120,7 +83,7 @@ const dev = defineCommand({
       if (watcher) {
         watcher.close();
       }
-      await silgiCLIIClose();
+      await silgiClose();
       process.exit(0);
     });
     consola.withTag("silgi").success("Prepare completed");

package/dist/cli/env.mjs

@@ -0,0 +1,40 @@
+import * as p from '@clack/prompts';
+import { setupDotenv } from 'silgi';
+
+let initialized = false;
+async function prepareEnv(silgiConfig) {
+  if (initialized)
+    return;
+  initialized = true;
+  const customEnvironments = silgiConfig.environments;
+  const environment = silgiConfig.activeEnvironment ? silgiConfig.activeEnvironment : await p.select({
+    message: "Select an environment",
+    options: customEnvironments?.length > 0 ? customEnvironments.map((env) => ({
+      label: env.fileName,
+      value: env.fileName
+    })) : [
+      { label: "Development (.env.dev)", value: "dev" },
+      { label: "Docker (.env.docker)", value: "docker" },
+      { label: "Staging (.env.staging)", value: "staging" },
+      { label: "Testing (.env.testing)", value: "testing" },
+      { label: "Production (.env)", value: ".env" }
+    ]
+  });
+  const findEnv = customEnvironments?.find((env) => env.fileName === environment);
+  if (findEnv) {
+    await setupDotenv({
+      cwd: findEnv.cwd || silgiConfig.rootDir,
+      interpolate: findEnv.interpolate,
+      fileName: findEnv.fileName,
+      env: findEnv.env
+    });
+  } else {
+    await setupDotenv({
+      cwd: silgiConfig.rootDir,
+      interpolate: true,
+      fileName: environment === ".env" ? ".env" : `.env.${environment}`
+    });
+  }
+}
+
+export { prepareEnv as p };

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.24.18";
+const version = "0.24.19";
 const packageJson = {
 	version: version};
 

package/dist/cli/install.mjs

@@ -3,45 +3,13 @@ import { readFileSync } from 'node:fs';
 import { defineCommand, runCommand } from 'citty';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
+import { loadOptions } from 'silgi';
 import { version } from 'silgi/meta';
 import { c as commonArgs, p as prepare } from './prepare.mjs';
-import { l as loadOptions } from './types.mjs';
-import './writeTypesAndFiles.mjs';
-import 'knitwork';
-import 'silgi/kit';
-import 'node:fs/promises';
-import 'hookable';
-import 'silgi';
-import 'silgi/runtime/meta';
-import 'unimport';
-import '../_chunks/routeRules.mjs';
-import 'unctx';
-import 'ufo';
 import '@clack/prompts';
-import 'dotenv';
-import 'mlly';
 import 'dev-jiti';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'untyped';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import 'pathe/utils';
 import 'picocolors';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
+import './env.mjs';
 
 const install = defineCommand({
   meta: {

package/dist/cli/prepare.mjs

@@ -1,16 +1,14 @@
 import { defineCommand, runCommand } from 'citty';
 import { resolve } from 'pathe';
+import { useSilgi, loadOptions, silgiClose, createSilgi, prepare as prepare$2, writeTypesAndFiles, writeCoreFile, prepareBuild } from 'silgi';
 import { version } from 'silgi/meta';
-import { d as prepareEnv, c as createSilgiCLI, a as prepare$2, b as writeTypesAndFiles, w as writeCoreFile, p as prepareBuild } from './writeTypesAndFiles.mjs';
 import { execSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import * as p from '@clack/prompts';
 import { consola } from 'consola';
 import { createJiti } from 'dev-jiti';
 import color from 'picocolors';
-import { useSilgiCLI } from 'silgi';
-import { a as silgiCLIIClose } from '../_chunks/routeRules.mjs';
-import { l as loadOptions } from './types.mjs';
+import { p as prepareEnv } from './env.mjs';
 
 const commonArgs = {
   dir: {
@@ -53,7 +51,7 @@ const run = defineCommand({
       consola.error("Silgi not found");
       return;
     }
-    const silgi = useSilgiCLI();
+    const silgi = useSilgi();
     const tags = args.tag?.split(",").map((t) => t.trim());
     p.intro(color.bold(`Silgi CLI ${color.green(`v${version}`)}`));
     const silgiConfig = await loadOptions({});
@@ -167,7 +165,7 @@ const run = defineCommand({
           alias: silgiConfig.alias
         });
         let cleanHandler = cmd.handler.handler.replace(/\n/g, "");
-        cleanHandler = `import { silgiCLICtx } from 'silgi' 
+        cleanHandler = `import { silgiCtx } from 'silgi' 
         ${cleanHandler}
 `;
         await jiti.evalModule(cleanHandler, {
@@ -178,7 +176,7 @@ const run = defineCommand({
         });
       }
     }
-    await silgiCLIIClose();
+    await silgiClose();
   }
 });
 
@@ -218,7 +216,7 @@ const prepare = defineCommand({
   },
   async run({ args }) {
     const rootDir = resolve(args.dir || args._dir || ".");
-    const silgi = await createSilgiCLI({
+    const silgi = await createSilgi({
       rootDir,
       dev: args.dev || args.stub,
       stub: args.stub,
@@ -226,7 +224,7 @@ const prepare = defineCommand({
       commandType: "prepare",
       activeEnvironment: args.env
     });
-    await prepare$2();
+    await prepare$2(silgi);
     await writeTypesAndFiles(silgi);
     await writeCoreFile(silgi);
     await prepareBuild(silgi);

package/dist/index.d.mts

@@ -1,8 +1,260 @@
-export { BaseError, ErrorCategory, ErrorFactory, ErrorMetadata, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCLICtx, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
-import { SilgiCLI, SilgiCLIConfig, LoadConfigOptions } from 'silgi/types';
-import 'unctx';
-import '@standard-schema/spec';
-import 'unstorage';
+import * as unctx from 'unctx';
+import { Silgi, SilgiCLI, SilgiConfig, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiStorageBase, SilgiCLIConfig, LoadConfigOptions, SilgiCLIOptions, DotenvOptions } from 'silgi/types';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Storage, StorageValue } from 'unstorage';
+import { Stats } from 'node:fs';
+
+declare const silgiAppCtx: unctx.UseContext<Silgi>;
+declare const silgiCtx: unctx.UseContext<SilgiCLI>;
+declare function useSilgiApp(): Silgi;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ * @example
+ * ```js
+ * const silgi = tryUseSilgiApp()
+ * if (silgi) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseSilgiApp(): Silgi | null;
+declare function useSilgi(): SilgiCLI;
+declare function silgiClose(): Promise<void>;
+declare function tryUseSilgi(): SilgiCLI | null;
+
+declare function createSilgiApp(config: SilgiConfig): Promise<Silgi>;
+
+declare function silgi(event?: SilgiEvents | Record<string, any>): SilgiFunction;
+
+interface RouteTemplateValidator {
+    (value: string): boolean;
+}
+interface RouteTemplateConfig {
+    pattern: string;
+    validators?: Record<string, RouteTemplateValidator>;
+}
+type URITemplate = string | RouteTemplateConfig;
+declare function parseURI(uri: string, uris: Record<string, URITemplate>): SilgiOperation;
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+declare function mergeSchemas<T extends MergedSilgiSchema[]>(typesOrArray: [...T] | T): UnionToIntersection<T[number]>;
+declare function mergeServices<T extends ServiceType<SilgiSchema>[]>(servicesOrArray: [...T] | T): RequiredServiceType<SilgiSchema>;
+declare function mergeShared<T extends SilgiRuntimeSharedsExtend[]>(sharedOrArray: [...T] | T): UnionToIntersection<T[number]>;
+
+declare function getEvent<T extends SilgiEvents>(event?: SilgiEvents): T;
+declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvents): T;
+
+declare function createSchema<T extends Partial<Record<keyof DefaultNamespaces, Record<string, BaseSchemaType<StandardSchemaV1>>>>>(silgiType: T): {
+    [K in keyof T]: {
+        [P in keyof T[K]]: T[K][P];
+    };
+};
+
+declare function createService<T extends SilgiSchema>(variables: ServiceType<T>): ServiceType<T>;
+
+declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
+
+/**
+ * Recursively replaces values starting with 'runtime.' with their actual values from runtime config
+ */
+declare function replaceRuntimeValues(obj: any, runtime: any): any;
+
+declare function createStorage(silgi: Silgi): Promise<Storage<StorageValue>>;
+declare function useSilgiStorage<T extends StorageValue = StorageValue>(base?: StorageConfig<T>['base'] | (string & {})): Storage<T>;
+
+declare enum HttpStatus {
+    /** [100] Server has received the request headers and client should proceed to send the request body */
+    CONTINUE = 100,
+    /** [101] Server is switching protocols according to Upgrade header */
+    SWITCHING_PROTOCOLS = 101,
+    /** [102] Server is processing the request but no response is available yet */
+    PROCESSING = 102,
+    /** [103] Server is likely to send a final response with the header fields in the informational response */
+    EARLY_HINTS = 103,
+    /** [200] Request succeeded and response contains requested data */
+    OK = 200,
+    /** [201] Request succeeded and new resource has been created */
+    CREATED = 201,
+    /** [202] Request accepted for processing but processing not completed */
+    ACCEPTED = 202,
+    /** [203] Request processed successfully but response may be from another source */
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    /** [204] Request processed successfully but response has no content */
+    NO_CONTENT = 204,
+    /** [205] Server fulfilled the request and client should reset the document view */
+    RESET_CONTENT = 205,
+    /** [206] Server delivered only part of the resource due to range header */
+    PARTIAL_CONTENT = 206,
+    /** [207] Response conveys information about multiple resources for XML messages */
+    MULTI_STATUS = 207,
+    /** [208] Members of DAV binding have already been enumerated and not included again */
+    ALREADY_REPORTED = 208,
+    /** [226] Server has fulfilled a GET request, response is result of transformations */
+    IM_USED = 226,
+    /** [300] Multiple options for the resource from which client may choose */
+    MULTIPLE_CHOICES = 300,
+    /** [301] Resource permanently moved to new URL */
+    MOVED_PERMANENTLY = 301,
+    /** [302] Resource temporarily moved to different URL */
+    FOUND = 302,
+    /** [303] Response to request found at another URL using GET */
+    SEE_OTHER = 303,
+    /** [304] Resource has not been modified since last requested */
+    NOT_MODIFIED = 304,
+    /** [305] Deprecated. Resource must be accessed through proxy */
+    USE_PROXY = 305,
+    /** [307] Resource temporarily moved to different URL, keep method */
+    TEMPORARY_REDIRECT = 307,
+    /** [308] Resource permanently moved to different URL, keep method */
+    PERMANENT_REDIRECT = 308,
+    /** [400] Request malformed, syntax error or invalid request */
+    BAD_REQUEST = 400,
+    /** [401] Request requires user authentication or authorization */
+    UNAUTHORIZED = 401,
+    /** [402] Reserved for future use, payment required */
+    PAYMENT_REQUIRED = 402,
+    /** [403] Server understood request but refuses to authorize it */
+    FORBIDDEN = 403,
+    /** [404] Server cannot find the requested resource */
+    NOT_FOUND = 404,
+    /** [405] Request method (GET, POST, etc.) not supported for this resource */
+    METHOD_NOT_ALLOWED = 405,
+    /** [406] Resource cannot generate response matching accept headers */
+    NOT_ACCEPTABLE = 406,
+    /** [407] Client must first authenticate with the proxy */
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    /** [408] Server timed out waiting for the request */
+    REQUEST_TIMEOUT = 408,
+    /** [409] Request conflicts with current state of the server */
+    CONFLICT = 409,
+    /** [410] Resource requested is no longer available and will not be available again */
+    GONE = 410,
+    /** [411] Server requires Content-Length header field */
+    LENGTH_REQUIRED = 411,
+    /** [412] Precondition given in request headers evaluated to false */
+    PRECONDITION_FAILED = 412,
+    /** [413] Request entity larger than limits defined by server */
+    PAYLOAD_TOO_LARGE = 413,
+    /** [414] URI requested by client is longer than server can interpret */
+    URI_TOO_LONG = 414,
+    /** [415] Media format of requested data not supported by server */
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    /** [416] Range specified by Range header cannot be fulfilled */
+    RANGE_NOT_SATISFIABLE = 416,
+    /** [417] Expectation indicated by Expect header cannot be met */
+    EXPECTATION_FAILED = 417,
+    /** [418] April Fools' joke by RFC 2324 - Server refuses to brew coffee in a teapot */
+    IM_A_TEAPOT = 418,
+    /** [421] Request directed at a server that is not configured to produce a response */
+    MISDIRECTED_REQUEST = 421,
+    /** [422] Server understands content type but cannot process contained instructions */
+    UNPROCESSABLE_ENTITY = 422,
+    /** [423] Requested resource is currently locked */
+    LOCKED = 423,
+    /** [424] Request failed due to failure of a previous request */
+    FAILED_DEPENDENCY = 424,
+    /** [425] Server is unwilling to risk processing a request that might be replayed */
+    TOO_EARLY = 425,
+    /** [426] Server requires client to upgrade to a different protocol */
+    UPGRADE_REQUIRED = 426,
+    /** [428] Origin server requires request to be conditional */
+    PRECONDITION_REQUIRED = 428,
+    /** [429] User has sent too many requests in a given time period */
+    TOO_MANY_REQUESTS = 429,
+    /** [431] Server refusing to process request due to oversized headers */
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    /** [451] Server denies access for legal reasons (e.g., censorship) */
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    /** [500] Generic server error, no specific message */
+    INTERNAL_SERVER_ERROR = 500,
+    /** [501] Server does not recognize method or lacks ability to fulfill */
+    NOT_IMPLEMENTED = 501,
+    /** [502] Bad response received from upstream server */
+    BAD_GATEWAY = 502,
+    /** [503] Server temporarily unavailable (overloaded/maintenance) */
+    SERVICE_UNAVAILABLE = 503,
+    /** [504] Gateway server did not get response from upstream server */
+    GATEWAY_TIMEOUT = 504,
+    /** [505] Server does not support the HTTP protocol version */
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    /** [506] Server has a circular reference in content negotiation */
+    VARIANT_ALSO_NEGOTIATES = 506,
+    /** [507] Server has insufficient storage to complete request */
+    INSUFFICIENT_STORAGE = 507,
+    /** [508] Server detected an infinite loop while processing request */
+    LOOP_DETECTED = 508,
+    /** [510] Further extensions needed for server to fulfill request */
+    NOT_EXTENDED = 510,
+    /** [511] Client needs to authenticate to gain network access */
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+}
+declare enum ErrorSeverity {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    ERROR = "ERROR",
+    CRITICAL = "CRITICAL"
+}
+declare enum ErrorCategory {
+    AUTHENTICATION = "auth",
+    AUTHORIZATION = "authorization",
+    VALIDATION = "validation",
+    BUSINESS = "business",
+    INFRASTRUCTURE = "infrastructure",
+    EXTERNAL = "external",
+    UNKNOWN = "unknown"
+}
+interface ErrorMetadata {
+    timestamp: number;
+    correlationId?: string;
+    requestId?: string;
+    userId?: string;
+    path?: string;
+    source?: string;
+    [key: string]: unknown;
+}
+interface BaseError {
+    code: number;
+    message: string;
+    category: ErrorCategory;
+    severity: ErrorSeverity;
+    httpStatus: HttpStatus;
+    metadata?: ErrorMetadata;
+    cause?: Error;
+    context?: Record<string, unknown>;
+}
+declare class ErrorFactory {
+    private static createMetadata;
+    static create(options: Partial<BaseError> & {
+        message: string;
+    }): SilgiError;
+    static authenticationError(message: string, context?: Record<string, unknown>): SilgiError;
+    static authorizationError(message: string, context?: Record<string, unknown>): SilgiError;
+    static validationError(message: string, context?: Record<string, unknown>): SilgiError;
+    static notFoundError(message: string, context?: Record<string, unknown>): SilgiError;
+    static internalError(message: string, cause?: Error): SilgiError;
+}
+declare class SilgiError extends Error implements BaseError {
+    readonly code: number;
+    readonly category: ErrorCategory;
+    readonly severity: ErrorSeverity;
+    readonly httpStatus: HttpStatus;
+    readonly metadata: ErrorMetadata;
+    readonly context?: Record<string, unknown>;
+    readonly cause?: Error;
+    constructor(error: BaseError);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+    static isError(error: unknown): error is SilgiError;
+    static from(error: unknown): SilgiError;
+}
+declare function isBaseError(error: unknown): error is BaseError;
+
+declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage['mount']>[1]) => T;
+
+declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
 
 /**
  * Prepares route rules for the build
@@ -11,10 +263,23 @@ declare function prepareBuild(silgi: SilgiCLI): Promise<void>;
 
 declare function prepare(_silgi: SilgiCLI): Promise<void>;
 
-declare function createSilgiCLI(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
+declare function reloadScan(path: string, _stats?: Stats): Promise<void>;
+
+type Env = typeof process.env;
+/**
+ * Load and interpolate environment variables into `process.env`.
+ * If you need more control (or access to the values), consider using `loadDotenv` instead
+ *
+ */
+declare function setupDotenv(options: DotenvOptions): Promise<Env>;
+
+declare function createSilgi(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
 
 declare function writeCoreFile(silgi: SilgiCLI): Promise<void>;
 
 declare function writeTypesAndFiles(silgi: SilgiCLI): Promise<void>;
 
-export { createSilgiCLI, prepare, prepareBuild, writeCoreFile, writeTypesAndFiles };
+declare const autoImportTypes: string[];
+
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createSilgiApp, createStorage, getEvent, getEventContext, isBaseError, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, prepare, prepareBuild, reloadScan, replaceRuntimeValues, setupDotenv, silgi, silgiAppCtx, silgiClose, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiApp, useSilgi, useSilgiApp, useSilgiStorage, writeCoreFile, writeTypesAndFiles };
+export type { BaseError, ErrorMetadata };