silgi 0.33.2 → 0.34.1

package/dist/types/index.d.mts

@@ -2,16 +2,16 @@ import { ApifulConfig } from 'apiful/config';
 import { C12InputConfig, ResolvedConfig, ConfigWatcher, WatchConfigOptions } from 'c12';
 import { ChokidarOptions } from 'chokidar';
 import { DateString, CompatibilityDateSpec, CompatibilityDates } from 'compatx';
-import { ConsolaInstance, LogLevel, ConsolaOptions } from 'consola';
+import { ConsolaInstance, ConsolaOptions, LogLevel } from 'consola';
 import { Hookable, NestedHooks } from 'hookable';
 import { Ignore, Options } from 'ignore';
 import { TSConfig } from 'pkg-types';
 import { PresetName, PresetOptions, PresetNameInput } from 'silgi/presets';
-import { ResolvedServiceType as ResolvedServiceType$1, SilgiRuntimeShareds as SilgiRuntimeShareds$1, SilgiRuntimeOptions as SilgiRuntimeOptions$1, RouteRules as RouteRules$1, ModuleMeta as ModuleMeta$1, SilgiModule as SilgiModule$1, BuildSilgi as BuildSilgi$1, Commands as Commands$1, SilgiRouteRules as SilgiRouteRules$1, DotenvOptions as DotenvOptions$1, EnvOptions as EnvOptions$1, SilgiRuntimeConfig as SilgiRuntimeConfig$1, ServiceParseModule as ServiceParseModule$1, SilgiCLIHooks as SilgiCLIHooks$1, StorageMounts as StorageMounts$1, SilgiTemplate as SilgiTemplate$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1 } from 'silgi/types';
+import { SilgiRuntimeShareds as SilgiRuntimeShareds$1, ModuleMeta as ModuleMeta$1, SilgiModule as SilgiModule$1, BuildSilgi as BuildSilgi$1, SilgiSchema as SilgiSchema$1, SilgiEvent as SilgiEvent$1, SilgiRuntimeActions as SilgiRuntimeActions$1, StorageConfig as StorageConfig$1, Commands as Commands$1, DotenvOptions as DotenvOptions$1, EnvOptions as EnvOptions$1, SilgiRuntimeConfig as SilgiRuntimeConfig$1, SilgiCLIHooks as SilgiCLIHooks$1, StorageMounts as StorageMounts$1, SilgiTemplate as SilgiTemplate$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1 } from 'silgi/types';
 import { Adapter, TablesSchema, InferModelTypes } from 'unadapter/types';
 import { UnimportPluginOptions } from 'unimport/unplugin';
 import * as h3 from 'h3';
-import { H3Event } from 'h3';
+import { HTTPMethod as HTTPMethod$1, Session, H3Event } from 'h3';
 import * as nitropack_types from 'nitropack/types';
 import { NitroRuntimeConfig } from 'nitropack/types';
 import { Defu } from 'defu';
@@ -21,11 +21,11 @@ import { ESMImport, ESMCodeGenOptions } from 'knitwork';
 import { Unimport } from 'unimport';
 import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
 import { StandardSchemaV1 } from '@standard-schema/spec';
+import { RouterContext } from 'rou3';
+import { silgiFetch } from 'silgi';
 import { ProviderName } from 'std-env';
 import { FetchOptions, FetchResponse } from 'ofetch';
 
-type HookResult = Promise<void> | void;
-
 interface SilgiCompatibilityIssue {
     name: string;
     message: string;
@@ -37,20 +37,45 @@ interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
     toString: () => string;
 }
 
+type RequiredServiceType<T> = {
+    [K in keyof T]-?: T[K] extends Record<string, any> ? {
+        [P in keyof T[K]]-?: any;
+    } : never;
+};
+type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
+type HookResult = Promise<void> | void;
+interface EnvOptions {
+    prefix?: string;
+    altPrefix?: string;
+    silgiPrefix?: string;
+    envExpansion?: boolean;
+}
+type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends any[] ? false : true : false;
+/**
+ * Recursively merges two object types. Properties in U override properties in T.
+ * @template T - The base object type.
+ * @template U - The object type to merge into T.
+ */
+type DeepMerge<A, B> = {
+    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? IsPlainObject<A[K]> extends true ? IsPlainObject<B[K]> extends true ? DeepMerge<A[K], B[K]> : B[K] : B[K] : B[K] : K extends keyof A ? A[K] : never;
+};
+/**
+ * Merges an array of object types recursively using DeepMerge.
+ * @template T - A tuple type containing the object types to merge.
+ */
+type MergeAll<T extends readonly any[]> = T extends [infer First, ...infer Rest] ? Rest extends [] ? First : DeepMerge<First, MergeAll<Rest>> : object;
+
 interface SilgiCLI {
     _ignore?: Ignore;
     errors: {
         type: 'Parser';
         path?: string;
     }[];
-    services: ResolvedServiceType$1;
+    services: ResolvedServiceDefinition;
     shareds: SilgiRuntimeShareds$1;
-    uris: Record<string, any>;
     schemas: Record<string, any>;
-    modulesURIs: Partial<Record<keyof SilgiRuntimeOptions$1 | (string & {}), any>>;
     scannedURIs: Map<string, string>;
     templates: SilgiTemplate[];
-    routeRules: RouteRules$1;
     hooks: Hookable<SilgiCLIHooks>;
     hook: SilgiCLI['hooks']['hook'];
     callHook: SilgiCLI['hooks']['callHook'];
@@ -104,10 +129,8 @@ interface ScanFile {
     context: string;
     object: {
         schemas: any;
-        uris: any;
         services: any;
         shareds: any;
-        modulesURIs: any;
     };
     path: string;
 }
@@ -210,11 +233,10 @@ interface SilgiCLIHooks extends SilgiHooks {
     }) => HookResult;
     'after:core.ts': (content: string[]) => HookResult;
     'before:scan.ts': (data: {
-        uris: Record<string, string>;
         services: string[];
         shareds: string[];
+        routers: string[];
         schemas: string[];
-        modulesURIs: Record<string, string>;
         addImportItem: (data: GenImport | GenImport[]) => void;
         addImportItemType: (data: GenImport | GenImport[]) => void;
     }) => HookResult;
@@ -234,14 +256,6 @@ interface SilgiCLIHooks extends SilgiHooks {
             key: string;
             value: string;
         }[];
-        routeRules: {
-            key: string;
-            value: string;
-        }[];
-        routeRulesConfig: {
-            key: string;
-            value: string;
-        }[];
         contexts: {
             key: string;
             value: string;
@@ -259,7 +273,7 @@ interface SilgiCLIHooks extends SilgiHooks {
             value: string;
             /**
              * If extends is true, it won't be added to the key value interface.
-             * interface SilgiModuleEventsExtends extends SilgiEvents {}
+             * interface SilgiModuleEventsExtends extends SilgiEvent {}
              */
             extends?: boolean;
             isSilgiContext?: boolean;
@@ -301,132 +315,356 @@ interface GenerateAppOptions {
     filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
 
-/**
- * Bu nitrojs, h3 event or request context.
- */
-interface SilgiEvents extends Record<string, unknown> {
-}
+type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer S4}/${infer _}` ? `/${S1}/${S2}/${S3}/${S4}` : T;
+type AllPaths = SilgiRouterTypes extends {
+    keys: infer U;
+} ? keyof U extends never ? string : keyof U : string;
+type ExtractPathParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractPathParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : unknown;
 
-interface SilgiSchema {
+type HttpMethod = 'get' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'head' | 'patch' | 'post' | 'put' | 'delete' | 'connect' | 'options' | 'trace';
+type RouterParams<R extends AllPaths | (string & {})> = ExtractPathParams<R>;
+type SilgiFetchOptions<P extends AllPaths | (string & {}), BasePath extends keyof SilgiRouterTypes = TrimAfterFourSlashes<P> extends keyof SilgiRouterTypes ? TrimAfterFourSlashes<P> : never, M extends keyof SilgiRouterTypes[BasePath] = keyof SilgiRouterTypes[BasePath]> = {
+    method?: M;
+    params?: ExtractPathParams<P>;
+    body?: SilgiRouterTypes[BasePath][M]['input'];
+} & Omit<FetchOptions, 'method' | 'body' | 'params'>;
+type SilgiFetchClient = <P extends AllPaths | (string & {}), BasePath extends keyof SilgiRouterTypes = TrimAfterFourSlashes<P> extends keyof SilgiRouterTypes ? TrimAfterFourSlashes<P> : never, M extends keyof SilgiRouterTypes[BasePath] = keyof SilgiRouterTypes[BasePath]>(url: BasePath, options?: SilgiFetchOptions<P, BasePath, M>) => Promise<FetchResponse<SilgiRouterTypes[BasePath][M]['output']>>;
+
+interface SilgiAppPlugin {
+    (silgi: Silgi): Promise<void> | void;
 }
-interface MergedSilgiSchema {
+
+interface CapturedErrorContext {
+    event?: SilgiEvent;
+    [key: string]: unknown;
 }
-type BaseSchemaType<T extends StandardSchemaV1> = {
-    [Action in BaseSilgiMethodType]?: Record<string, {
-        input?: T;
-        output?: T;
-        pathParams?: T;
-        queryParams?: T;
-        source?: T;
-    }>;
-};
+type CaptureError = (silgi: Silgi, error: Error, context: CapturedErrorContext) => void;
 
-interface SilgiURIs {
+/**
+ * Yardımcı tipler
+ */
+type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
+type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
+type ServiceHandlerParameters<S, R extends keyof S, M extends keyof S[R]> = S[R][M] extends {
+    pathParams?: infer P;
+} ? S[R][M] extends {
+    queryParams?: infer Q;
+} ? (P extends undefined ? object : {
+    path: InferInput<P>;
+}) & (Q extends undefined ? object : {
+    query: InferInput<Q>;
+}) : (P extends undefined ? object : {
+    path: InferInput<P>;
+}) : S[R][M] extends {
+    queryParams?: infer Q;
+} ? (Q extends undefined ? object : {
+    query: InferInput<Q>;
+}) : object;
+/**
+ * Route ve method'a göre input, output, params çıkarımı
+ */
+type ServiceHandlerInput<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], HiddenParameters extends boolean = false> = (Schema[Route][Method] extends {
+    input?: infer I;
+} ? {
+    args: InferInput<I>;
+} : unknown) & (HiddenParameters extends false ? (keyof ServiceHandlerParameters<Schema, Route, Method> extends never ? unknown : {
+    parameters: ServiceHandlerParameters<Schema, Route, Method>;
+}) : unknown);
+type ServiceHandlerOutput<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route]> = Schema[Route][Method] extends {
+    output?: infer O;
+} ? InferOutput<O> : unknown;
+type ServiceHandlerSource<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route]> = Schema[Route][Method] extends {
+    source?: infer S;
+} ? InferInput<S> : unknown;
+/**
+ * Handler fonksiyon tipi
+ *
+ * Resolved = false  -> handler(input, shared, event, source) // all required
+ * Resolved = true -> handler(input, shared?, event?, source?) // only input required
+ */
+type ServiceHandler<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false, HiddenParameters extends boolean = false> = Resolved extends true ? (input: ServiceHandlerInput<Schema, Route, Method, HiddenParameters>, shared?: SilgiRuntimeShareds$1, event?: SilgiEvent$1, source?: ServiceHandlerSource<Schema, Route, Method>) => Promise<ServiceHandlerOutput<Schema, Route, Method>> : (input: ServiceHandlerInput<Schema, Route, Method, HiddenParameters>, shared: SilgiRuntimeShareds$1, event: SilgiEvent$1, source: ServiceHandlerSource<Schema, Route, Method>) => Promise<ServiceHandlerOutput<Schema, Route, Method>>;
+/**
+ * Servis setup tipi
+ */
+interface ServiceSetup<Schema extends SilgiSchema$1 = SilgiSchema$1, Route extends keyof Schema = keyof Schema, Method extends keyof Schema[Route] = keyof Schema[Route], Resolved extends boolean = false, HiddenParameters extends boolean = false> {
+    handler: ServiceHandler<Schema, Route, Method, Resolved, HiddenParameters>;
+    modules?: Partial<SilgiRuntimeActions$1>;
+    storage?: StorageConfig$1<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
 }
-type URIsTypes<T extends Record<string, string>> = {
-    [K in keyof T]: string;
+/**
+ * Servis tanımı (tek bir route+method için)
+ */
+type ServiceDefinition<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false> = {
+    [R in Route]: {
+        [M in Method]: ServiceSetup<Schema, R, M, Resolved>;
+    };
 };
-type ExtractPath<T extends string> = T extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
-    service: Service;
-    entity: Entity;
+/**
+ * Çoklu servisleri birleştirmek için yardımcı tip
+ */
+type MergeServiceDefinitions<T extends object[]> = T extends [infer F, ...infer R] ? F & MergeServiceDefinitions<R extends object[] ? R : []> : unknown;
+/**
+ * Servis oluşturmak için parametreler
+ */
+interface CreateServiceParams<Schema extends SilgiSchema$1, Route extends keyof Schema, Method extends keyof Schema[Route], Resolved extends boolean = false> {
+    route: Route;
     method: Method;
-    action: Action;
-} : never : never;
-type GetInput<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    input: infer I;
-} ? I extends StandardSchemaV1 ? StandardSchemaV1.InferInput<I> : never : never : never : never : never : never;
-type GetOutput<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    output: infer O;
-} ? O extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<O> : never : never : never : never : never : never;
-type GetSource<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    source: infer I;
-} ? I : never : never : never : never : never;
-type GetQueryParams<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    queryParams: infer Q;
-} ? Q : never : never : never : never : never;
-type GetPathParams<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    pathParams: infer Q;
-} ? Q : never : never : never : never : never;
-type ExtractInputFromURI<TURI extends keyof SilgiURIs> = GetInput<ExtractPath<TURI>>;
-type ExtractSourceFromURI<TURI extends keyof SilgiURIs> = GetSource<ExtractPath<TURI>>;
-type ExtractOutputFromURI<TURI extends keyof SilgiURIs> = GetOutput<ExtractPath<TURI>>;
-type ExtractQueryParamsFromURI<TURI extends keyof SilgiURIs> = GetQueryParams<ExtractPath<TURI>>;
-type ExtractPathParamsFromURI<TURI extends keyof SilgiURIs> = GetPathParams<ExtractPath<TURI>>;
+    setup: ServiceSetup<Schema, Route, Method, Resolved>;
+}
+/**
+ * SilgiURL tipi
+ */
+interface SilgiURL {
+    namespaceName: string;
+    prefixName: string;
+    methodName: string;
+    path: string;
+    raw: string;
+    pathParams?: Record<string, string | undefined>;
+    queryParams?: Record<string, string>;
+}
 
 /**
- * @example
- * namespace: 'coreApi'
- * serviceName: 'basket'
- * method: 'post'
- * action: 'createBasket'
+ * The listeners to Silgi
  */
-interface SilgiOperation {
+interface SilgiRuntimeHooks {
     /**
-     * 'coreApi'
-     * 'storageApi'
+     * Called after Silgi initialization, when the Silgi instance is ready to work.
+     * @param silgi The configured Silgi object
+     * @returns Promise
      */
-    namespaceName: keyof DefaultNamespaces;
+    'ready': (silgi: Silgi) => HookResult;
     /**
-     * 'basket'
-     * 'user'
+     * Called when silgi instance is gracefully closing.
+     * @param silgi The configured silgi object
+     * @returns Promise
      */
-    serviceName: string;
+    'close': (silgi: Silgi) => HookResult;
+    'app:setup:start': (silgi: Silgi) => HookResult;
+    'request:on': (event: SilgiEvent) => HookResult;
+    'execute:after': (context: ModuleHookContext) => HookResult;
+    'execute:error': (context: ModuleHookContext) => HookResult;
+    'execute:finally': (context: ModuleHookContext) => HookResult;
+    'event:init': (event: SilgiEvent, data: {
+        path: string;
+        queryParams?: Record<string, string>;
+        url: SilgiURL;
+    }) => HookResult;
+    'error': CaptureError;
+}
+
+type CustomDriverName = string & {
+    _custom?: any;
+};
+interface StorageMounts {
+    [path: string]: {
+        driver: BuiltinDriverName | CustomDriverName;
+        [option: string]: any;
+    };
+}
+interface SilgiStorageBase {
+}
+type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
+interface StorageConfig<TInput> {
+    options: TransactionOptions;
+    base: 'memory' | keyof SilgiStorageBase;
+    key?: StorageKeyGenerator<TInput>;
+    scope?: 'request' | 'global';
+}
+interface StorageKeyParams<TInput = unknown> {
+    url: SilgiURL;
+    input: TInput;
+    requestId?: string;
+    keyGenerator?: StorageKeyGenerator<TInput>;
+    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
+}
+
+interface SilgiRuntimeConfig {
+}
+interface SilgiOptions {
+    consolaOptions?: Partial<ConsolaOptions>;
+    present: PresetNameInput;
+    hooks: Partial<SilgiRuntimeHooks & DefaultHooks>;
     /**
-     * 'post'
-     * 'delete'
+     * Set to `true` to enable debug mode.
+     *
+     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
+     *
+     * @default false
      */
-    methodName: string;
+    debug: boolean;
+    storage: StorageMounts;
+    putStorage?: Storage<StorageValue>;
+    runtimeConfig: SilgiRuntimeConfig & {
+        [key: string]: any;
+    };
+    captureError: CaptureError;
+    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
+    [key: string]: any;
+}
+
+interface SilgiSchema {
+}
+interface MergedSilgiSchema {
+}
+/**
+ * Utility type for schema generics to avoid repetition
+ */
+interface SchemaParams<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TPathParams extends StandardSchemaV1 | undefined = undefined, TQueryParams extends StandardSchemaV1 | undefined = undefined, TSource extends StandardSchemaV1 | undefined = undefined> {
+    input?: TInput;
+    output?: TOutput;
+    pathParams?: TPathParams;
+    queryParams?: TQueryParams;
+    source?: TSource;
+}
+/**
+ * Defines the structure for schema components within a service endpoint.
+ * Allows specifying schemas for input, output, path parameters, query parameters, and source data.
+ * @template TInput - The schema type for the request body/input.
+ * @template TOutput - The schema type for the response body/output.
+ * @template TPathParams - The schema type for URL path parameters.
+ * @template TQueryParams - The schema type for URL query parameters.
+ * @template TSource - The schema type for the source data or context.
+ */
+type SchemaDefinition<TInput extends StandardSchemaV1 | undefined = undefined, TOutput extends StandardSchemaV1 | undefined = undefined, TPathParams extends StandardSchemaV1 | undefined = undefined, TQueryParams extends StandardSchemaV1 | undefined = undefined, TSource extends StandardSchemaV1 | undefined = undefined> = SchemaParams<TInput, TOutput, TPathParams, TQueryParams, TSource>;
+/**
+ * ResolvedServiceDefinition: ServiceDefinition with generics resolved.
+ * Represents the fully resolved service definition structure.
+ */
+interface ResolvedSchemaDefinition {
+    [route: string]: {
+        [method in HTTPMethod$1]: {
+            input?: StandardSchemaV1;
+            output?: StandardSchemaV1;
+            pathParams?: StandardSchemaV1;
+            queryParams?: StandardSchemaV1;
+            source?: StandardSchemaV1;
+        };
+    };
+}
+
+interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
+    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
+    runtimeConfig: SilgiRuntimeConfig;
+    $fetch: typeof silgiFetch;
+}
+interface SilgiRuntimeSharedsExtend {
+}
+interface ExtendShared {
+}
+
+interface FrameworkContext {
+}
+type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+interface SilgiRoute {
+    route: string;
+    method?: HTTPMethod;
+    setup: ServiceSetup;
+    schema: ResolvedSchemaDefinition;
+}
+interface Silgi {
+    router: RouterContext<SilgiRoute>;
+    routerPrefixs: string[];
+    schemas: ResolvedSchemaDefinition;
+    services: ResolvedServiceDefinition;
+    shared: SilgiRuntimeShareds;
+    plugins: SilgiAppPlugin[];
+    framework: FrameworkContext;
+    _ignore?: Ignore;
+    hooks: Hookable<SilgiRuntimeHooks & DefaultHooks>;
+    hook: Silgi['hooks']['hook'];
+    callHook: Silgi['hooks']['callHook'];
+    addHooks: Silgi['hooks']['addHooks'];
+    ready: () => Promise<void>;
+    close: () => Promise<void>;
+    logger: ConsolaInstance;
+    storage: Storage;
+    envOptions: EnvOptions;
+    options: SilgiOptions & SilgiRuntimeOptions;
+    captureError: CaptureError;
+}
+interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRuntimeOptions> {
+    options: DeepPartial<SilgiOptions>;
+}
+interface BuildSilgi {
+    framework: FrameworkContext;
+    modules?: Partial<SilgiRuntimeOptions>;
+    options?: Partial<SilgiOptions>;
+}
+type CustomRequestInit<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> = Omit<RequestInit, 'body' | 'headers' | 'method'> & {
+    method: Method;
+    body?: Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+        input?: infer I;
+    } ? I extends StandardSchemaV1 ? StandardSchemaV1.InferInput<I> : unknown : unknown : unknown : unknown;
+    headers?: Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+        headers?: infer H;
+    } ? H extends StandardSchemaV1 ? StandardSchemaV1.InferInput<H> : unknown : unknown : unknown : unknown;
+} & (Route extends keyof Schema ? Method extends keyof Schema[Route] ? Schema[Route][Method] extends {
+    pathParams?: infer P;
+} ? P extends StandardSchemaV1 ? {
+    pathParams: StandardSchemaV1.InferInput<P>;
+} : {
+    pathParams?: unknown;
+} : {
+    pathParams?: unknown;
+} : {
+    pathParams?: unknown;
+} : {
+    pathParams?: unknown;
+});
+
+interface ExtendContext {
+}
+interface SilgiRuntimeContext extends Record<string, any> {
+    params?: Record<string, string>;
     /**
-     * 'createBasket'
-     * 'deleteUser'
+     * Matched router Node
+     *
+     * @experimental The object structure may change in non-major version.
      */
-    actionName: string;
+    matchedRoute?: SilgiRoute;
+    sessions?: Record<string, Session>;
+    clientAddress?: string;
+    source?: any;
+}
+interface ServerRequest extends Request {
     /**
-     * 'coreApi/basket/post/createBasket'
+     * IP address of the client.
      */
-    raw: string;
+    ip?: string | undefined;
+}
+/**
+ * Bu nitrojs, h3 event or request context.
+ */
+interface SilgiEvent extends Record<string, unknown> {
     /**
-     * '/book/basket/getAllBaskets'
+     * Event context.
      */
-    uri: keyof SilgiURIs;
+    readonly context: SilgiRuntimeContext;
     /**
-     * ['coreApi', 'book', 'basket', 'getAllBaskets']
+     * Incoming HTTP request info.
+     *
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
      */
-    parts: string[];
+    readonly req: ServerRequest;
     /**
-     * {id: '123', name: 'John', bookId: '456', authorId: '789'}
+     * Access to the parsed request URL.
+     *
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/URL)
      */
-    routerParams?: Record<string, string | undefined>;
+    readonly url: URL;
     /**
-     * url ?limit=10&page=1
-     * {limit: '10', page: '1'}
+     * Prepared HTTP response.
      */
-    query?: Record<string, string>;
+    readonly res: {
+        status?: number;
+        statusText?: string;
+        readonly headers: Headers;
+    };
 }
 
 interface SilgiRuntimeActions {
@@ -484,20 +722,14 @@ interface ResolvedModuleMeta extends ModuleMeta {
     name: string;
 }
 type ModuleHookContext = Readonly<{
-    event?: SilgiEvents;
-    operation?: SilgiOperation;
+    event: SilgiEvent;
+    url: SilgiURL;
     input?: unknown;
-    source?: any;
     result?: unknown;
     modules?: SilgiRuntimeActions;
-    timestamp?: number;
-    meta?: Record<string, unknown>;
     error?: Error;
     success?: boolean;
     cached?: boolean;
-    config?: {
-        returnNull: boolean;
-    };
 }>;
 /** The options received.  */
 type ModuleOptionsCustom = Record<string, any>;
@@ -550,9 +782,6 @@ type DeepRequired<T> = T extends (...args: any[]) => any ? T : T extends Record<
     [P in keyof T]-?: DeepRequired<T[P]>;
 } : T;
 type Awaitable<T> = T | Promise<T>;
-interface CreateScope {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<ExtractOutputFromURI<TURI>>;
-}
 declare global {
     var $silgiStatus: CommandType;
     var _silgi_runtime: SilgiRuntimeOptions;
@@ -594,7 +823,6 @@ interface SilgiCLIOptions extends PresetOptions {
     };
     commandType: CommandType;
     commands: Commands$1[];
-    routeRules: SilgiRouteRules$1;
     schemaVendor: Schema | Schema[];
     environments: DotenvOptions$1[];
     activeEnvironment: 'prod' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
@@ -602,7 +830,6 @@ interface SilgiCLIOptions extends PresetOptions {
     runtimeConfig: SilgiRuntimeConfig$1 & {
         [key: string]: any;
     };
-    serviceParseModules: ServiceParseModule$1[];
     storages: string[];
     namespaces: string[];
     hooks: NestedHooks<SilgiCLIHooks$1>;
@@ -840,304 +1067,6 @@ interface LoadConfigOptions {
     consola?: ConsolaInstance;
 }
 
-type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer S4}/${infer _}` ? `/${S1}/${S2}/${S3}/${S4}` : T;
-type AllPaths = SilgiRouterTypes extends {
-    keys: infer U;
-} ? keyof U extends never ? string : keyof U : string;
-type ExtractPathParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
-    [K in Param]: string;
-} & ExtractPathParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
-    [K in Param]: string;
-} : unknown;
-
-type HttpMethod = 'get' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'head' | 'patch' | 'post' | 'put' | 'delete' | 'connect' | 'options' | 'trace';
-type RouterParams<R extends AllPaths | (string & {})> = ExtractPathParams<R>;
-type SilgiFetchOptions<P extends AllPaths | (string & {}), BasePath extends keyof SilgiRouterTypes = TrimAfterFourSlashes<P> extends keyof SilgiRouterTypes ? TrimAfterFourSlashes<P> : never, M extends keyof SilgiRouterTypes[BasePath] = keyof SilgiRouterTypes[BasePath]> = {
-    method?: M;
-    params?: ExtractPathParams<P>;
-    body?: SilgiRouterTypes[BasePath][M]['input'];
-} & Omit<FetchOptions, 'method' | 'body' | 'params'>;
-type SilgiFetchClient = <P extends AllPaths | (string & {}), BasePath extends keyof SilgiRouterTypes = TrimAfterFourSlashes<P> extends keyof SilgiRouterTypes ? TrimAfterFourSlashes<P> : never, M extends keyof SilgiRouterTypes[BasePath] = keyof SilgiRouterTypes[BasePath]>(url: BasePath, options?: SilgiFetchOptions<P, BasePath, M>) => Promise<FetchResponse<SilgiRouterTypes[BasePath][M]['output']>>;
-
-interface EnvOptions {
-    prefix?: string;
-    altPrefix?: string;
-    silgiPrefix?: string;
-    envExpansion?: boolean;
-}
-
-interface DefaultRouteConfig extends SilgiRuntimeRouteRulesConfig {
-    splat?: boolean;
-    doubleSplat?: boolean;
-    [key: string]: any;
-}
-interface DefaultRouteRules extends SilgiRuntimeRouteRules {
-    [key: string]: any;
-}
-type SilgiRouteRules = Record<DefaultRouteRules extends string ? DefaultRouteRules : string, DefaultRouteConfig>;
-interface SilgiRuntimeRouteRules {
-}
-interface SilgiRuntimeRouteRulesConfig {
-}
-/**
- * Interface for the object returned by createRouteRules
- */
-interface RouteRules {
-    readonly rules: Record<string, DefaultRouteConfig>;
-    readonly mergedRules: Record<string, DefaultRouteConfig>;
-    importRules: (config: Record<string, DefaultRouteConfig>) => void;
-    exportRules: () => Record<string, DefaultRouteConfig>;
-    addRule: (pattern: string, config: DefaultRouteConfig) => void;
-    updateRule: (pattern: string, config: Partial<DefaultRouteConfig>) => void;
-    removeRule: (pattern: string) => void;
-    matchesRule: (url: string, pattern: string) => boolean;
-    getMatchingPatterns: (url: string) => string[];
-    getConfig: (url: string) => DefaultRouteConfig | null;
-    getParams: (url: string, pattern: string) => Record<string, string> | null;
-    match: (url: string) => {
-        pattern: string;
-        config: DefaultRouteConfig;
-        params: Record<string, string> | null;
-    } | null;
-    clear: () => void;
-    clearMergedRules: () => void;
-    precomputeMergedRules: (urls: string[]) => void;
-    setMergedRule: (url: string, config: DefaultRouteConfig) => void;
-    getMergedRules: () => Record<string, DefaultRouteConfig>;
-    configure: (config: Record<string, DefaultRouteConfig>) => void;
-    updateMergeRules: () => Record<string, DefaultRouteConfig>;
-}
-
-type CustomDriverName = string & {
-    _custom?: any;
-};
-interface StorageMounts {
-    [path: string]: {
-        driver: BuiltinDriverName | CustomDriverName;
-        [option: string]: any;
-    };
-}
-interface SilgiStorageBase {
-}
-type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
-    options: TransactionOptions;
-    base: 'memory' | keyof SilgiStorageBase;
-    key?: StorageKeyGenerator<TInput>;
-    scope?: 'request' | 'global';
-}
-interface StorageKeyParams<TInput = unknown> {
-    operation: SilgiOperation;
-    input: TInput;
-    requestId?: string;
-    keyGenerator?: StorageKeyGenerator<TInput>;
-    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
-}
-
-interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
-    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
-    silgi: SilgiFunction;
-    runtimeConfig: SilgiRuntimeConfig;
-}
-interface SilgiRuntimeSharedsExtend {
-}
-interface ExtendShared {
-}
-
-type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
-type MethodHandlerType<T> = {
-    routeRules?: DefaultRouteConfig;
-} & {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        routeRules?: DefaultRouteConfig;
-    } & {
-        [Method in keyof T[Action]]?: {
-            default?: {
-                input?: StandardSchemaV1.InferInput<T[Action][Method]['input']> & {
-                    parameters: StandardSchemaV1.InferInput<T[Action][Method]['pathParams']> & StandardSchemaV1.InferInput<T[Action][Method]['queryParams']>;
-                };
-                output?: StandardSchemaV1.InferInput<T[Action][Method]['output']>;
-                source?: StandardSchemaV1.InferInput<T[Action][Method]['source']>;
-            };
-            handler: (input: StandardSchemaV1.InferInput<T[Action][Method]['input']> & {
-                parameters: StandardSchemaV1.InferInput<T[Action][Method]['pathParams']> & StandardSchemaV1.InferInput<T[Action][Method]['queryParams']>;
-            }, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<T[Action][Method]['source']>) => EventHandlerResponse<StandardSchemaV1.InferOutput<T[Action][Method]['output']>>;
-            modules?: Partial<SilgiRuntimeActions>;
-            routeRules?: DefaultRouteConfig;
-            storage?: StorageConfig<T[Action][Method]['input']>;
-        };
-    } : never;
-};
-interface ResolvedMethodHandlerType {
-    input?: Partial<BaseSchemaType<any>>;
-    output: Partial<BaseSchemaType<any>>;
-    handler: (input: StandardSchemaV1.InferInput<any> & {
-        parameters: any;
-    }, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<any>) => Promise<StandardSchemaV1.InferInput<any>>;
-    modules?: Partial<SilgiRuntimeActions>;
-    storage?: StorageConfig<StandardSchemaV1.InferInput<any>>;
-    routeRules?: SilgiRouteRules;
-    execute: (input: StandardSchemaV1.InferInput<any>, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<any>) => Promise<StandardSchemaV1.InferInput<any>>;
-}
-
-type SilgiServiceInterface<T extends BaseSchemaType<StandardSchemaV1>> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            input: T[Action][Method]['input'];
-            output: T[Action][Method]['output'];
-            /**
-             * Example: /api/v1/users/{id}/{name}/{surname}
-             */
-            pathParams: T[Action][Method]['pathParams'];
-            /**
-             * Example: /api/v1/users?name=ali&surname=veli
-             */
-            queryParams: T[Action][Method]['queryParams'];
-            source: T[Action][Method]['source'];
-        };
-    } : never;
-};
-type ServiceType<T> = Partial<{
-    [Namespace in keyof T]: T[Namespace] extends Record<string, any> ? {
-        routeRules?: DefaultRouteConfig;
-    } & {
-        [Service in keyof T[Namespace]]?: Partial<MethodHandlerType<T[Namespace][Service]>>;
-    } : never;
-}>;
-type RequiredServiceType<T> = {
-    [K in keyof T]-?: T[K] extends Record<string, any> ? {
-        [P in keyof T[K]]-?: MethodHandlerType<T[K][P]>;
-    } : never;
-};
-/**
- * const test: ResolvedServiceType = {
-  aaa: {
-    bbb: {
-      delete: {
-        storage: {
-          handler: () => {}
-        },
-      },
-    },
-  },
-}
- */
-type ResolvedServiceType = {
-    [K in string]: {
-        [P in string]: {
-            [Q in BaseSilgiMethodType]?: {
-                [M in string]: ResolvedMethodHandlerType;
-            };
-        };
-    };
-};
-
-interface FrameworkContext {
-}
-interface Silgi {
-    schemas: any;
-    services: RequiredServiceType<SilgiSchema>;
-    shared: SilgiRuntimeShareds;
-    uris: Record<string, any>;
-    modulesURIs: Partial<Record<keyof SilgiRuntimeOptions | (string & {}), any>>;
-    scannedHandlers: Map<string, ResolvedMethodHandlerType>;
-    plugins: SilgiAppPlugin[];
-    framework: FrameworkContext;
-    routeRules: RouteRules;
-    _ignore?: Ignore;
-    hooks: Hookable<SilgiRuntimeHooks & DefaultHooks>;
-    hook: Silgi['hooks']['hook'];
-    callHook: Silgi['hooks']['callHook'];
-    addHooks: Silgi['hooks']['addHooks'];
-    ready: () => Promise<void>;
-    close: () => Promise<void>;
-    logger: ConsolaInstance;
-    storage: Storage;
-    envOptions: EnvOptions;
-    options: SilgiOptions & SilgiRuntimeOptions;
-    captureError: CaptureError;
-}
-interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRuntimeOptions> {
-    options: DeepPartial<SilgiOptions>;
-}
-interface SilgiFunction {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>, source?: ExtractSourceFromURI<TURI>, queryParams?: Record<string, string>) => Promise<ExtractOutputFromURI<TURI>>;
-}
-interface BuildSilgi {
-    framework: FrameworkContext;
-    modules?: Partial<SilgiRuntimeOptions>;
-    options?: Partial<SilgiOptions>;
-}
-
-interface SilgiAppPlugin {
-    (silgi: Silgi): Promise<void> | void;
-}
-
-interface CapturedErrorContext {
-    event?: SilgiEvents;
-    [key: string]: unknown;
-}
-type CaptureError = (silgi: Silgi, error: Error, context: CapturedErrorContext) => void;
-
-/**
- * The listeners to Silgi
- */
-interface SilgiRuntimeHooks {
-    /**
-     * Called after Silgi initialization, when the Silgi instance is ready to work.
-     * @param silgi The configured Silgi object
-     * @returns Promise
-     */
-    'ready': (silgi: Silgi) => HookResult;
-    /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
-     */
-    'close': (silgi: Silgi) => HookResult;
-    'app:setup:start': (silgi: Silgi) => HookResult;
-    'execute:before': (context: ModuleHookContext) => HookResult;
-    'execute:after': (context: ModuleHookContext) => HookResult;
-    'execute:error': (context: ModuleHookContext) => HookResult;
-    'execute:finally': (context: ModuleHookContext) => HookResult;
-    'event:init': (event: SilgiEvents, data: {
-        path: string;
-        queryParams?: Record<string, string>;
-        operation: SilgiOperation;
-    }) => HookResult;
-    'error': CaptureError;
-}
-
-interface SilgiRuntimeConfig {
-}
-interface SilgiOptions {
-    consolaOptions?: Partial<ConsolaOptions>;
-    routeRules: SilgiRouteRules;
-    present: PresetNameInput;
-    hooks: Partial<SilgiRuntimeHooks & DefaultHooks>;
-    /**
-     * Set to `true` to enable debug mode.
-     *
-     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
-     *
-     * @default false
-     */
-    debug: boolean;
-    storage: StorageMounts;
-    putStorage?: Storage<StorageValue>;
-    runtimeConfig: SilgiRuntimeConfig & {
-        [key: string]: any;
-    };
-    captureError: CaptureError;
-    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
-    [key: string]: any;
-}
-
-interface SilgiRuntimeContext extends Record<string, any> {
-}
-interface ExtendContext {
-}
-
 interface DotenvOptions {
     /**
      * The project root directory (either absolute or relative to the current working directory).
@@ -1173,23 +1102,64 @@ interface GraphQLJSON {
     references: any;
 }
 
-interface BaseNamespaceType extends Record<keyof DefaultNamespaces, Record<string, BaseSchemaType<StandardSchemaV1>>> {
-}
-type Namespaces<T extends BaseNamespaceType> = {
-    [K in keyof T]: {
-        [P in keyof T[K]]: T[K][P] extends BaseSchemaType<StandardSchemaV1> ? SilgiServiceInterface<T[K][P]> : never;
-    };
-};
-
-interface ServiceParse {
-    node: ResolvedMethodHandlerType;
-    basePath: string;
-    silgi: SilgiCLI;
-    modulesURIs: Record<string, Record<string, any>>;
-    pathLength: number;
+/**
+ * Main interface containing all route definitions.
+ * Example:
+ * {
+ *   "/api/blueSpace/basket/getBook": { ... }
+ * }
+ */
+interface Routers {
 }
-interface ServiceParseModule {
-    (params: ServiceParse): Awaited<void> | void;
+/**
+ * Extracts the prefix (first segment) from a URL, including the leading slash.
+ * @example ExtractPrefix<'/api/blueSpace/basket'> // '/api'
+ */
+type ExtractPrefix<URL extends string> = URL extends `/${infer Prefix}/${string}` ? `/${Prefix}` : never;
+/**
+ * Extracts the namespace (second segment) from a URL, including the leading slash.
+ * @example ExtractNamespace<'/api/blueSpace/basket'> // '/blueSpace'
+ */
+type ExtractNamespace<URL extends string> = URL extends `/${string}/${infer Namespace}/${string}` ? `/${Namespace}` : never;
+/**
+ * Extracts the route (third and subsequent segments) from a URL, including the leading slash.
+ * @example ExtractRoute<'/api/blueSpace/basket/getBook'> // '/basket/getBook'
+ */
+type ExtractRoute<URL extends string> = URL extends `/${string}/${string}/${infer Route}` ? `/${Route}` : never;
+/**
+ * Gets all route keys from Routers as strings.
+ * All keys should start with a leading slash.
+ */
+type RouterKeys = keyof Routers & string;
+/**
+ * Extracts all prefixes (first segment) in the system, including the leading slash.
+ * @example AllPrefixes // '/api' | ...
+ */
+type AllPrefixes = RouterKeys extends infer K ? K extends string ? ExtractPrefix<K> : never : never;
+/**
+ * Extracts all namespaces (second segment) for a given prefix, including the leading slash.
+ * @example NamespacesForPrefix<'/api'> // '/blueSpace' | ...
+ */
+type NamespacesForPrefix<P extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}/${infer N}/${string}` ? `/${N}` : never : never : never;
+/**
+ * Extracts all routes (third and subsequent segments) for a given prefix and namespace, including the leading slash.
+ * @example RoutesForPrefixAndNamespace<'/api', '/blueSpace'> // '/basket/getBook' | ...
+ */
+type RoutesForPrefixAndNamespace<P extends string, N extends string> = RouterKeys extends infer K ? K extends string ? K extends `${P}${N}${infer R}` ? `${R}` : never : never : never;
+/**
+ * Extracts path parameter keys from a URL pattern string.
+ *
+ * @example
+ * ExtractPathParamKeys<'/users/:id/posts/:postId'> // 'id' | 'postId'
+ * ExtractPathParamKeys<'/users/:id?'> // 'id'
+ */
+type ExtractPathParamKeys<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param extends `${infer Key}?` ? Key | ExtractPathParamKeys<Rest> : Param | ExtractPathParamKeys<Rest> : S extends `${string}:${infer Param}` ? Param extends `${infer Key}?` ? Key : Param : never;
+/**
+ * Route configuration interface.
+ */
+interface RouteConfig<T> {
+    route: T;
+    setup?: any;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, Schema, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };
+export type { AllPaths, AllPrefixes, AppConfig, Awaitable, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateServiceParams, CustomRequestInit, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractNamespace, ExtractPathParamKeys, ExtractPathParams, ExtractPrefix, ExtractRoute, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HTTPMethod, HookResult, HttpMethod, LoadConfigOptions, MergeAll, MergeServiceDefinitions, MergedSilgiSchema, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, NamespacesForPrefix, NitroBuildInfo, RequiredServiceType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedSchemaDefinition, ResolvedSilgiTemplate, RouteConfig, RouterParams, Routers, RoutesForPrefixAndNamespace, ScanFile, Schema, SchemaDefinition, SchemaParams, ServiceDefinition, ServiceHandler, ServiceHandlerInput, ServiceHandlerOutput, ServiceHandlerSource, ServiceSetup, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvent, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRoute, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiStorageBase, SilgiTemplate, SilgiURL, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes };