silgi 0.24.16 → 0.24.18

package/dist/{shared/silgi.CvG35CGc.mjs → cli/writeTypesAndFiles.mjs}

@@ -5,18 +5,19 @@ import { existsSync, promises, readFileSync, writeFileSync, mkdirSync } from 'no
 import { readdir, readFile } from 'node:fs/promises';
 import consola, { consola as consola$1 } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
-import { useSilgiCLI as useSilgiCLI$1, replaceRuntimeValues, silgiCLICtx as silgiCLICtx$1, autoImportTypes } from 'silgi';
+import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
 import { runtimeDir } from 'silgi/runtime/meta';
 import { scanExports, createUnimport, toExports } from 'unimport';
-import { withoutTrailingSlash, withLeadingSlash, isRelative, withTrailingSlash } from 'ufo';
+import { c as createRouteRules } from '../_chunks/routeRules.mjs';
 import * as p from '@clack/prompts';
 import * as dotenv from 'dotenv';
 import { resolveModuleExportNames, findTypeExports, findExports, resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
 import { createJiti } from 'dev-jiti';
-import { h as hasInstalledModule } from './silgi.DWfN_DdY.mjs';
+import { h as hasInstalledModule } from './compatibility.mjs';
 import { fileURLToPath } from 'node:url';
 import defu, { defu as defu$1 } from 'defu';
 import { resolveModuleURL } from 'exsolve';
+import { isRelative, withTrailingSlash } from 'ufo';
 import { generateTypes, resolveSchema } from 'untyped';
 import { globby } from 'globby';
 import ignore from 'ignore';
@@ -25,9 +26,8 @@ import { klona } from 'klona';
 import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
 import { createStorage, builtinDrivers } from 'unstorage';
 import { peerDependencies } from 'silgi/meta';
-import { l as loadOptions, s as silgiGenerateType } from './silgi.BIBmUBIR.mjs';
+import { l as loadOptions, s as silgiGenerateType } from './types.mjs';
 import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-import { createContext } from 'unctx';
 
 async function prepareBuild(silgi) {
   try {
@@ -70,291 +70,6 @@ export const routeRules = ${genObjectFromRawEntries(
 async function prepare(_silgi) {
 }
 
-function patternToRegex(pattern) {
-  let regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  regexStr = regexStr.replace(/\*\*/g, ".+");
-  regexStr = regexStr.replace(/\*/g, "[^/]+");
-  regexStr = regexStr.replace(/:([^/]+)/g, "([^/]+)");
-  return new RegExp(`^${regexStr}$`);
-}
-function extractParams(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (!pattern.includes(":"))
-    return null;
-  const paramNames = [];
-  const patternRegex = pattern.replace(/:([^/]+)/g, (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  const regex = new RegExp(`^${patternRegex}$`);
-  const matches = url.match(regex);
-  if (!matches)
-    return null;
-  const params = {};
-  paramNames.forEach((name, i) => {
-    params[name] = matches[i + 1];
-  });
-  return Object.keys(params).length > 0 ? params : null;
-}
-function matchesPattern(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (url === pattern)
-    return true;
-  if (pattern.endsWith("/**")) {
-    const basePath = pattern.slice(0, -3);
-    return url === basePath || url.startsWith(`${basePath}/`);
-  }
-  const urlParts = url.split("/");
-  const patternParts = pattern.split("/");
-  if (!pattern.includes("**") && urlParts.length !== patternParts.length) {
-    return false;
-  }
-  if (pattern.includes("/**/")) {
-    const [prefix, ...suffixParts] = pattern.split("/**/");
-    const suffix = suffixParts.join("/");
-    return url.startsWith(prefix) && (!suffix || url.endsWith(`/${suffix}`));
-  }
-  return patternToRegex(pattern).test(url);
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object")
-    return obj;
-  if (typeof obj === "function")
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(deepClone);
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      cloned[key] = deepClone(obj[key]);
-    }
-  }
-  return cloned;
-}
-function mergeConfigs(...configs) {
-  const result = {};
-  for (const config of configs) {
-    if (!config)
-      continue;
-    for (const key in config) {
-      const value = config[key];
-      if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && typeof result[key] !== "function") {
-        const resultValue = result[key];
-        const valueToMerge = value;
-        result[key] = mergeConfigs(resultValue, valueToMerge);
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function createRouteRules() {
-  let _rules = {};
-  let _mergedRules = {};
-  let _rulesModified = false;
-  function getRules() {
-    return deepClone(_rules);
-  }
-  function importRules(config) {
-    const normalizedConfig = {};
-    for (const pattern in config) {
-      normalizedConfig[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config[pattern]);
-    }
-    _rules = normalizedConfig;
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function exportRules() {
-    return deepClone(_rules);
-  }
-  function addRule(pattern, config) {
-    _rules[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config);
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function updateRule(pattern, config) {
-    const normalizedPattern = withoutTrailingSlash(withLeadingSlash(pattern));
-    if (_rules[normalizedPattern]) {
-      _rules[normalizedPattern] = { ..._rules[normalizedPattern], ...deepClone(config) };
-    } else {
-      _rules[normalizedPattern] = deepClone(config);
-    }
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function removeRule(pattern) {
-    delete _rules[withoutTrailingSlash(withLeadingSlash(pattern))];
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function matchesRule(url, pattern) {
-    return matchesPattern(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function getMatchingPatterns(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    return Object.keys(_rules).filter((pattern) => matchesPattern(normalizedUrl, pattern)).sort((a, b) => {
-      if (a === url)
-        return -1;
-      if (b === url)
-        return 1;
-      const aSegments = a.split("/").filter(Boolean).length;
-      const bSegments = b.split("/").filter(Boolean).length;
-      if (aSegments !== bSegments)
-        return bSegments - aSegments;
-      const aWildcards = (a.match(/\*/g) || []).length;
-      const bWildcards = (b.match(/\*/g) || []).length;
-      if (aWildcards !== bWildcards)
-        return aWildcards - bWildcards;
-      const aDoubleWildcards = (a.match(/\*\*/g) || []).length;
-      const bDoubleWildcards = (b.match(/\*\*/g) || []).length;
-      if (aDoubleWildcards !== bDoubleWildcards)
-        return aDoubleWildcards - bDoubleWildcards;
-      return b.length - a.length;
-    });
-  }
-  function getConfig(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    if (_mergedRules[normalizedUrl]) {
-      return deepClone(_mergedRules[normalizedUrl]);
-    }
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const mergedConfig = {};
-    for (let i = patterns.length - 1; i >= 0; i--) {
-      const pattern = patterns[i];
-      const patternConfig = _mergedRules[pattern] || _rules[pattern];
-      Object.assign(mergedConfig, deepClone(patternConfig));
-    }
-    _mergedRules[normalizedUrl] = deepClone(mergedConfig);
-    return mergedConfig;
-  }
-  function computeMergedConfig(url, patterns) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const matchingPatterns = patterns || getMatchingPatterns(normalizedUrl);
-    if (!matchingPatterns.length)
-      return {};
-    const allPatternsHaveCache = matchingPatterns.every((pattern) => !!_mergedRules[pattern]);
-    if (allPatternsHaveCache) {
-      return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_mergedRules[pattern])), {});
-    }
-    return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_rules[pattern])), {});
-  }
-  function getParams(url, pattern) {
-    return extractParams(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function match(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const bestPattern = patterns[0];
-    return {
-      pattern: bestPattern,
-      config: deepClone(_rules[bestPattern]),
-      params: getParams(normalizedUrl, bestPattern)
-    };
-  }
-  function clear() {
-    _rules = {};
-    clearMergedRules();
-    _rulesModified = false;
-  }
-  function clearMergedRules() {
-    _mergedRules = {};
-    _rulesModified = true;
-  }
-  function precomputeMergedRules(urls) {
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    for (const url of urls) {
-      const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-      if (!_mergedRules[normalizedUrl]) {
-        const patterns = getMatchingPatterns(normalizedUrl);
-        if (patterns.length) {
-          _mergedRules[normalizedUrl] = computeMergedConfig(normalizedUrl, patterns);
-        }
-      }
-    }
-  }
-  function setMergedRule(url, config) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    _mergedRules[normalizedUrl] = deepClone(config);
-    if (url.includes("*") || url.includes(":")) {
-      _rulesModified = false;
-    }
-  }
-  function getMergedRules() {
-    return deepClone(_mergedRules);
-  }
-  function configure(config) {
-    importRules(config);
-  }
-  function updateMergeRules() {
-    if (!_rulesModified) {
-      return _mergedRules;
-    }
-    _mergedRules = {};
-    const rulePatterns = Object.keys(_rules);
-    for (const pattern of rulePatterns) {
-      const patterns = getMatchingPatterns(pattern);
-      _mergedRules[pattern] = computeMergedConfig(pattern, patterns);
-    }
-    for (const pattern of rulePatterns) {
-      if (pattern.includes("/:")) {
-        const segments = pattern.split("/");
-        let partialPath = "";
-        for (const segment of segments) {
-          if (segment) {
-            partialPath += `/${segment}`;
-            if (segment.startsWith(":") && partialPath !== pattern) {
-              const samplePath = partialPath.replace(/:\w+/g, "sample");
-              const patterns = getMatchingPatterns(samplePath);
-              _mergedRules[samplePath] = computeMergedConfig(samplePath, patterns);
-            }
-          }
-        }
-      }
-    }
-    _rulesModified = false;
-    return _mergedRules;
-  }
-  return {
-    // Public getters that return a cloned version to prevent direct modification
-    get rules() {
-      return getRules();
-    },
-    get mergedRules() {
-      return getMergedRules();
-    },
-    // API methods
-    importRules,
-    exportRules,
-    addRule,
-    updateRule,
-    removeRule,
-    matchesRule,
-    getMatchingPatterns,
-    getConfig,
-    getParams,
-    match,
-    clear,
-    clearMergedRules,
-    precomputeMergedRules,
-    setMergedRule,
-    getMergedRules,
-    configure,
-    updateMergeRules
-  };
-}
-
 async function setupDotenv(options) {
   const targetEnvironment = options.env ?? process.env;
   const environment = await loadDotenv({
@@ -826,7 +541,7 @@ async function installModules(silgi, prepare = false) {
   }
   silgi.options.isPreparingModules = false;
 }
-async function installModule(moduleToInstall, silgi = useSilgiCLI$1(), inlineOptions, prepare = false) {
+async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions, prepare = false) {
   const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
   const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
   if (res === false) {
@@ -1174,7 +889,7 @@ class SchemaParser {
     };
   }
   parseVariableDeclaration(ast, path) {
-    const silgi = useSilgiCLI$1();
+    const silgi = useSilgiCLI();
     if (ast.program.body.length === 0) {
       if (safeFiles.find((i) => path.includes(i)))
         return [];
@@ -1188,7 +903,7 @@ class SchemaParser {
     return variableDeclarations;
   }
   parseTSInterfaceDeclaration(ast, path = "") {
-    const silgi = useSilgiCLI$1();
+    const silgi = useSilgiCLI();
     if (ast.program.body.length === 0) {
       if (safeFiles.find((i) => path.includes(i)))
         return [];
@@ -1941,12 +1656,12 @@ async function createSilgiCLI(config = {}, opts = {}) {
   const routeRules = createRouteRules();
   routeRules.importRules(options.routeRules ?? {});
   silgi.routeRules = routeRules;
-  if (silgiCLICtx$1.tryUse()) {
-    silgiCLICtx$1.unset();
-    silgiCLICtx$1.set(silgi);
+  if (silgiCLICtx.tryUse()) {
+    silgiCLICtx.unset();
+    silgiCLICtx.set(silgi);
   } else {
-    silgiCLICtx$1.set(silgi);
-    silgi.hook("close", () => silgiCLICtx$1.unset());
+    silgiCLICtx.set(silgi);
+    silgi.hook("close", () => silgiCLICtx.unset());
   }
   if (silgi.options.debug) {
     createDebugger(silgi.hooks, { tag: "silgi" });
@@ -2658,25 +2373,4 @@ async function writeTypesAndFiles(silgi) {
   }
 }
 
-const silgiCLICtx = createContext();
-function useSilgiCLI() {
-  const instance = silgiCLICtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-async function silgiCLIIClose() {
-  const silgi = silgiCLICtx.tryUse();
-  if (!silgi) {
-    return;
-  }
-  await silgi.close();
-  await silgi.callHook("close", silgi);
-  consola.withTag("silgi").success("Process terminated");
-}
-function tryUseSilgiCLI() {
-  return silgiCLICtx.tryUse();
-}
-
-export { prepare as a, writeCoreFile as b, createSilgiCLI as c, prepareBuild as d, createRouteRules as e, silgiCLICtx as f, prepareEnv as p, silgiCLIIClose as s, tryUseSilgiCLI as t, useSilgiCLI as u, writeTypesAndFiles as w };
+export { prepare as a, writeTypesAndFiles as b, createSilgiCLI as c, prepareEnv as d, prepareBuild as p, writeCoreFile as w };

package/dist/core/index.d.mts

@@ -0,0 +1,271 @@
+import * as unctx from 'unctx';
+import { Silgi, SilgiCLI, SilgiConfig, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiStorageBase } from 'silgi/types';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Storage, StorageValue } from 'unstorage';
+
+declare const silgiCtx: unctx.UseContext<Silgi>;
+declare function useSilgi(): Silgi;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ * @example
+ * ```js
+ * const silgi = tryUseSilgi()
+ * if (silgi) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseSilgi(): Silgi | null;
+
+declare const silgiCLICtx: unctx.UseContext<SilgiCLI>;
+declare function useSilgiCLI(): SilgiCLI;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ * @example
+ * ```js
+ * const silgi = tryUseSilgi()
+ * if (silgi) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseSilgiCLI(): SilgiCLI | null;
+
+declare function createSilgi(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 const autoImportTypes: string[];
+
+export { ErrorCategory, ErrorFactory, 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 };
+export type { BaseError, ErrorMetadata };