silgi 0.33.2 → 0.34.0

package/dist/cli/types.mjs

@@ -30,7 +30,6 @@ const SilgiCLIDefaults = {
       version: "0.0.1"
     }
   },
-  serviceParseModules: [],
   storages: [],
   devServer: {
     watch: []
@@ -69,19 +68,11 @@ const SilgiCLIDefaults = {
   // Modules
   _modules: [],
   modules: [],
-  routeRules: {},
-  // Features
-  // experimental: {},
   future: {},
   storage: {},
   devStorage: {},
   stub: false,
-  // bundledStorage: [],
-  // publicAssets: [],
-  // serverAssets: [],
   plugins: [],
-  // tasks: {},
-  // scheduledTasks: {},
   imports: {
     exclude: [],
     dirs: [],
@@ -268,7 +259,8 @@ function getSilgiImportsPreset() {
         "createShared",
         "useSilgi",
         "createService",
-        "createSchema"
+        "createSchema",
+        "createRouter"
       ]
     },
     // {

package/dist/cli/watch.mjs

@@ -14,8 +14,6 @@ import 'hookable';
 import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'unimport';
-import '../_chunks/routeRules.mjs';
-import 'ufo';
 import '@clack/prompts';
 import 'node:fs';
 import 'dotenv';
@@ -26,6 +24,7 @@ import 'semver/functions/satisfies.js';
 import 'node:url';
 import 'defu';
 import 'exsolve';
+import 'ufo';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';

package/dist/core/index.d.mts

@@ -1,37 +1,304 @@
-import { SilgiConfig, Silgi, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiCLI, SilgiStorageBase } from 'silgi/types';
+import { SilgiConfig, Silgi, SilgiEvent, SilgiSchema, ServiceSetup, CustomRequestInit, SilgiRuntimeContext, AllPrefixes, NamespacesForPrefix, RoutesForPrefixAndNamespace, HTTPMethod, ExtractPathParamKeys, MergeAll, SilgiRuntimeShareds, RouteConfig, StorageConfig, SilgiCLI, SilgiStorageBase } from 'silgi/types';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Storage, StorageValue } from 'unstorage';
 import { UseContext } from 'unctx';
 
 declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 
-declare function silgi(event?: SilgiEvents | Record<string, any>): SilgiFunction;
+declare function createSilgiCore(event: SilgiEvent): {
+    resolve: <Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = true, HiddenParameters extends boolean = false>(path: Route, method: Method, context: {
+        pathParams?: Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+            pathParams?: infer P;
+        } ? P extends StandardSchemaV1 ? StandardSchemaV1.InferInput<P> : undefined : undefined : undefined : undefined;
+    }) => Promise<Route extends keyof Schema ? Method extends keyof Schema[Route] ? ServiceSetup<Schema, Route, Method, Resolved, HiddenParameters> : undefined : undefined>;
+};
+/**
+ * Fetch API for Silgi framework
+ */
+declare function silgiFetch<Schema extends SilgiSchema = SilgiSchema, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = true, HiddenParameters extends boolean = true>(_request: Route, options?: CustomRequestInit<Schema, Route, Method, Resolved, HiddenParameters>, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
+/**
+ * Fetch API for Silgi framework using standard Request options
+ */
+declare function silgiFetch(_request: Request | URL | string, options?: RequestInit & {
+    pathParams?: Record<string, any>;
+}, context?: SilgiRuntimeContext): Promise<Response | Promise<Response>>;
 
-interface RouteTemplateValidator {
-    (value: string): boolean;
-}
-interface RouteTemplateConfig {
-    pattern: string;
-    validators?: Record<string, RouteTemplateValidator>;
+/**
+ * LICENSE: MIT
+ * Credits:
+ * - H3 - https://github.com/h3js/h3
+ */
+/**
+ * Silgi Runtime Error
+ * @class
+ * @extends Error
+ * @property {number} statusCode - An integer indicating the HTTP response status code.
+ * @property {string} statusMessage - A string representing the HTTP status message.
+ * @property {boolean} fatal - Indicates if the error is a fatal error.
+ * @property {boolean} unhandled - Indicates if the error was unhandled and auto-captured.
+ * @property {DataT} data - An extra data that will be included in the response.
+ *                         This can be used to pass additional information about the error.
+ */
+declare class SilgiError<DataT = unknown> extends Error {
+    static __silgi_error__: boolean;
+    statusCode: number;
+    fatal: boolean;
+    unhandled: boolean;
+    statusMessage?: string;
+    data?: DataT;
+    cause?: unknown;
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+    toJSON(): Pick<SilgiError<DataT>, 'message' | 'statusCode' | 'statusMessage' | 'data'>;
 }
-type URITemplate = string | RouteTemplateConfig;
-declare function parseURI(uri: string, uris: Record<string, URITemplate>): SilgiOperation;
+/**
+ * Creates a new `Error` that can be used to handle both internal and runtime errors.
+ *
+ * @param input {string | (Partial<SilgiError> & { status?: number; statusText?: string })} - The error message or an object containing error properties.
+ * If a string is provided, it will be used as the error `message`.
+ *
+ * @example
+ * // String error where `statusCode` defaults to `500`
+ * throw createError("An error occurred");
+ * // Object error
+ * throw createError({
+ *   statusCode: 400,
+ *   statusMessage: "Bad Request",
+ *   message: "Invalid input",
+ *   data: { field: "email" }
+ * });
+ *
+ *
+ * @return {SilgiError} - An instance of SilgiError.
+ *
+ * @remarks
+ * - Typically, `message` contains a brief, human-readable description of the error, while `statusMessage` is specific to HTTP responses and describes
+ * the status text related to the response status code.
+ * - In a client-server context, using a short `statusMessage` is recommended because it can be accessed on the client side. Otherwise, a `message`
+ * passed to `createError` on the server will not propagate to the client.
+ * - Consider avoiding putting dynamic user input in the `message` to prevent potential security issues.
+ */
+declare function createError<DataT = unknown>(input: string | (Partial<SilgiError<DataT>> & {
+    status?: number;
+    statusText?: string;
+})): SilgiError<DataT>;
+/**
+ * Checks if the given input is an instance of SilgiError.
+ *
+ * @param input {*} - The input to check.
+ * @return {boolean} - Returns true if the input is an instance of SilgiError, false otherwise.
+ */
+declare function isError<DataT = unknown>(input: any): input is SilgiError<DataT>;
 
-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]>;
+type MaybePromise<T> = T | Promise<T>;
+interface SilgiHandlerConfig {
+    debug?: boolean;
+    onError?: (error: SilgiError, event: SilgiEvent) => MaybePromise<void | unknown>;
+    onRequest?: (event: SilgiEvent) => MaybePromise<void>;
+    onBeforeResponse?: (event: SilgiEvent, response: Response | PreparedResponse) => MaybePromise<void>;
+}
+type PreparedResponse = ResponseInit & {
+    body?: BodyInit | null;
+};
+declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHandlerConfig): Response | Promise<Response>;
 
-declare function getEvent<T extends SilgiEvents>(event?: SilgiEvents): T;
-declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvents): T;
+declare function getEvent<T extends SilgiEvent>(event?: SilgiEvent): T;
+declare function getEventContext<T extends SilgiRuntimeContext>(event?: SilgiEvent): 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];
+/**
+ * Creates an object type representing path parameters extracted from a URL pattern.
+ *
+ * @example
+ * PathParamsObject<'/users/:id/posts/:postId'> // { id: string | number, postId: string | number }
+ */
+type PathParamsObject<S extends string> = {
+    [K in ExtractPathParamKeys<S>]: string | number;
+};
+/**
+ * Determines if a URL pattern contains any path parameters.
+ *
+ * @example
+ * HasPathParams<'/users/:id'> // true
+ * HasPathParams<'/users'> // false
+ */
+type HasPathParams<S extends string> = ExtractPathParamKeys<S> extends never ? false : true;
+/**
+ * Base schema definition for API method handlers.
+ * Defines the structure of input/output data.
+ */
+interface BaseMethodSchema {
+    /** Schema for request body */
+    input?: StandardSchemaV1;
+    /** Schema for response body */
+    output?: StandardSchemaV1;
+    /** Schema for URL query parameters */
+    queryParams?: StandardSchemaV1;
+    /** Schema for source data (contextual information) */
+    source?: StandardSchemaV1;
+}
+/**
+ * Interface for adding path parameters schema to method definitions.
+ */
+interface WithPathParams<PathParamsStr extends string> {
+    /** Schema for path parameters */
+    pathParams: StandardSchemaV1<PathParamsObject<PathParamsStr>>;
+}
+/**
+ * Defines the schema structure for HTTP methods, conditionally including
+ * path parameters based on the URL pattern.
+ *
+ * @example
+ * // For a route with path parameters:
+ * type UserMethodSchema = MethodSchemas<'/:id'>
+ * // Result includes required pathParams for each method
+ *
+ * // For a route without path parameters:
+ * type ListMethodSchema = MethodSchemas<''>
+ * // Result doesn't allow pathParams property
+ */
+type MethodSchemas<PathParamsStr extends string = ''> = {
+    [K in HTTPMethod]?: HasPathParams<PathParamsStr> extends true ? BaseMethodSchema & WithPathParams<PathParamsStr> : BaseMethodSchema & {
+        pathParams?: never;
     };
 };
+/**
+ * Creates a type-safe API route schema definition.
+ *
+ * This utility function helps you define API schemas with proper typing for
+ * input, output, path parameters, and query parameters.
+ *
+ * @template P - API prefix (e.g., '/api')
+ * @template N - API namespace (e.g., '/v1')
+ * @template R - Route path (e.g., '/users' or '/users/:id')
+ * @template Methods - HTTP method definitions
+ *
+ * @param params - Schema configuration parameters
+ * @returns Route schema object with complete type information
+ *
+ * @example
+ * // Define a user API schema with GET and POST methods
+ * const userSchema = createSchema({
+ *   prefix: '/api',
+ *   namespace: '/v1',
+ *   path: '/users',
+ *   methods: {
+ *     GET: {
+ *       output: z.object({
+ *         users: z.array(z.object({ id: z.string(), name: z.string() }))
+ *       })
+ *     },
+ *     POST: {
+ *       input: z.object({
+ *         name: z.string().min(2),
+ *         email: z.string().email()
+ *       }),
+ *       output: z.object({
+ *         id: z.string(),
+ *         created: z.boolean()
+ *       })
+ *     }
+ *   }
+ * });
+ *
+ * // Define a user detail API with path parameters
+ * const userDetailSchema = createSchema({
+ *   prefix: '/api',
+ *   namespace: '/v1',
+ *   path: '/users/:id',
+ *   methods: {
+ *     GET: {
+ *       pathParams: z.object({
+ *         id: z.string().uuid()
+ *       }),
+ *       output: z.object({
+ *         name: z.string(),
+ *         email: z.string(),
+ *         createdAt: z.date()
+ *       })
+ *     },
+ *     PUT: {
+ *       pathParams: z.object({
+ *         id: z.string().uuid()
+ *       }),
+ *       input: z.object({
+ *         name: z.string().optional(),
+ *         email: z.string().email().optional()
+ *       }),
+ *       queryParams: z.object({
+ *         version: z.number().optional()
+ *       })
+ *     },
+ *     DELETE: {
+ *       pathParams: z.object({
+ *         id: z.string().uuid()
+ *       }),
+ *       output: z.object({
+ *         success: z.boolean()
+ *       })
+ *     }
+ *   }
+ * });
+ *
+ * // Example with nested route parameters
+ * const postCommentSchema = createSchema({
+ *   prefix: '/api',
+ *   namespace: '/v1',
+ *   path: '/posts/:postId/comments/:commentId',
+ *   methods: {
+ *     GET: {
+ *       pathParams: z.object({
+ *         postId: z.string(),
+ *         commentId: z.string()
+ *       }),
+ *       output: z.object({
+ *         content: z.string(),
+ *         author: z.string()
+ *       })
+ *     },
+ *     PATCH: {
+ *       pathParams: z.object({
+ *         postId: z.string(),
+ *         commentId: z.string()
+ *       }),
+ *       input: z.object({
+ *         content: z.string().min(1).max(500)
+ *       })
+ *     }
+ *   }
+ * });
+ */
+declare function createSchema<P extends AllPrefixes, N extends NamespacesForPrefix<P>, R extends RoutesForPrefixAndNamespace<P, N>, Methods extends MethodSchemas<R> = MethodSchemas<R>>(params: {
+    /** API prefix, such as '/api' */
+    prefix: P;
+    /** API namespace, such as '/v1' */
+    namespace: N;
+    /** Route path, such as '/users' or '/users/:id' */
+    path: R;
+    /** HTTP method schemas */
+    methods: Methods;
+}): Record<`${P}${N}${R}`, Methods>;
 
-declare function createService<T extends SilgiSchema>(variables: ServiceType<T>): ServiceType<T>;
+/**
+ * Merges multiple service definition objects into a single object.
+ * Performs a complete deep merge of all service definition objects.
+ * @template T - A tuple type representing the array of service definition objects to merge.
+ * @param {T} schemas - An array of service definition objects created by `createSchema`.
+ * @returns {MergeAll<T>} A single object containing all merged service definitions.
+ */
+declare function deepMergeObjects<T extends readonly Record<string, any>[]>(schemas: [...T]): MergeAll<T>;
+
+type ServiceMethods<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> = {
+    [M in keyof Schema[Path]]?: ServiceSetup<Schema, Path, M, Resolved, HiddenParameters>;
+};
+declare function createService<Schema extends SilgiSchema, Path extends keyof Schema, Resolved extends boolean = false, Methods extends ServiceMethods<Schema, Path, Resolved> = ServiceMethods<Schema, Path, Resolved>>(params: {
+    path: Path;
+    methods: Methods;
+}): {
+    [R in Path]: {
+        [M in keyof Methods]: Methods[M];
+    };
+};
 
 declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntimeShareds;
 
@@ -40,197 +307,13 @@ declare function createShared(shared: Partial<SilgiRuntimeShareds>): SilgiRuntim
  */
 declare function replaceRuntimeValues(obj: any, runtime: any): any;
 
+declare function createRoute<URL extends string>(params: RouteConfig<URL>): {
+    [K in URL]: RouteConfig<URL>;
+};
+
 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 const silgiCtx: UseContext<Silgi>;
 declare function useSilgi(): Silgi;
 /**
@@ -255,5 +338,4 @@ declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base
 
 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 };
+export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createSilgiCore, createStorage, deepMergeObjects, getEvent, getEventContext, handleResponse, isError, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage };