silgi 0.37.38 → 0.37.40

package/dist/build.mjs

@@ -26,8 +26,8 @@ import 'defu';
 import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
-import 'globby';
 import 'oxc-parser';
+import 'tinyglobby';
 import 'ignore';
 import 'klona';
 import 'unstorage';

package/dist/cli/build.mjs

@@ -18,8 +18,8 @@ import { defu } from 'defu';
 import { resolveModuleURL } from 'exsolve';
 import { withTrailingSlash, isRelative } from 'ufo';
 import { readdir, readFile } from 'node:fs/promises';
-import { globby } from 'globby';
 import { parseAsync } from 'oxc-parser';
+import { glob } from 'tinyglobby';
 import ignore from 'ignore';
 import { klona } from 'klona';
 import { createStorage, builtinDrivers } from 'unstorage';
@@ -330,7 +330,7 @@ async function registerModuleExportScan(silgi) {
       if (!module.entryPath) {
         continue;
       }
-      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
+      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "moduleTypes.d.mts"), "utf8").catch(() => "");
       const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
       for (const e of findTypeExports(normalisedModuleTypes)) {
         moduleReExports.push(e);
@@ -753,7 +753,7 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
     return;
   }
   try {
-    const matchedFiles = await globby(serverDirectory, {
+    const matchedFiles = await glob(serverDirectory, {
       cwd: silgiInstance.options.rootDir,
       ignore: silgiInstance.options.ignore
     });
@@ -1397,7 +1397,7 @@ async function scanFiles(silgi, name) {
   return files;
 }
 async function scanDir(silgi, dir, name) {
-  const fileNames = await globby(join(name, GLOB_SCAN_PATTERN), {
+  const fileNames = await glob(join(name, GLOB_SCAN_PATTERN), {
     cwd: dir,
     dot: true,
     ignore: silgi.options.ignore,

package/dist/cli/index.mjs

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

package/dist/cli/init.mjs

@@ -23,8 +23,8 @@ import 'node:url';
 import 'defu';
 import 'exsolve';
 import 'ufo';
-import 'globby';
 import 'oxc-parser';
+import 'tinyglobby';
 import 'ignore';
 import 'klona';
 import 'unstorage';

package/dist/cli/install.mjs

@@ -26,8 +26,8 @@ import 'defu';
 import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
-import 'globby';
 import 'oxc-parser';
+import 'tinyglobby';
 import 'ignore';
 import 'klona';
 import 'unstorage';

package/dist/cli/types.mjs

@@ -76,7 +76,14 @@ const SilgiCLIDefaults = {
     presets: [],
     virtualImports: ["#silgiImports"]
   },
-  ignore: [],
+  ignore: [
+    "**/*.stories.{js,cts,mts,ts,jsx,tsx}",
+    "**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}",
+    "**/*.d.{cts,mts,ts}",
+    "**/.{pnpm-store,vercel,netlify,output,git,cache,data}",
+    ".silgi",
+    "**/-*.*"
+  ],
   // Dev
   dev: false,
   // devServer: { watch: [] },

package/dist/cli/watch.mjs

@@ -28,8 +28,8 @@ import 'defu';
 import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
-import 'globby';
 import 'oxc-parser';
+import 'tinyglobby';
 import 'ignore';
 import 'klona';
 import 'unstorage';

package/dist/types/index.d.mts

@@ -1,5 +1,5 @@
 import { ApifulConfig } from 'apiful/config';
-import { C12InputConfig, ResolvedConfig, ConfigWatcher, WatchConfigOptions } from 'c12';
+import { C12InputConfig, ResolvedConfig, ConfigWatcher, DotenvOptions as DotenvOptions$1, WatchConfigOptions } from 'c12';
 import { ChokidarOptions } from 'chokidar';
 import { DateString, CompatibilityDateSpec, CompatibilityDates } from 'compatx';
 import { ConsolaInstance, ConsolaOptions, LogLevel } from 'consola';
@@ -7,43 +7,27 @@ import { Hookable, NestedHooks } from 'hookable';
 import { Ignore, Options } from 'ignore';
 import { TSConfig } from 'pkg-types';
 import { PresetName, PresetOptions, PresetNameInput } from 'silgi/presets';
-import { ResolvedServiceDefinition as ResolvedServiceDefinition$1, SilgiRuntimeShareds as SilgiRuntimeShareds$1, ModuleMeta as ModuleMeta$1, SilgiModule as SilgiModule$1, BuildSilgi as BuildSilgi$1, SilgiSchema as SilgiSchema$1, SilgiEvent as SilgiEvent$1, RouteConfigService as RouteConfigService$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 { Defu } from 'defu';
 import * as next from 'next';
 import { NextConfig } from 'next';
 import { Stats } from 'node:fs';
 import * as h3 from 'h3';
-import { HTTPMethod as HTTPMethod$1, Session } from 'h3';
+import { Session, HTTPMethod as HTTPMethod$1 } from 'h3';
 import * as nitropack_types from 'nitropack/types';
 import { ESMImport, ESMCodeGenOptions } from 'knitwork';
-import { useRuntimeConfig } from 'silgi/runtime';
-import { Unimport } from 'unimport';
-import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
-import { ServerRequest } from 'srvx';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { NitroApp } from 'nitropack';
 import { RouterContext } from 'rou3';
+import { TransactionOptions, BuiltinDriverName, StorageValue, Storage } from 'unstorage';
+import { ServerRequest } from 'srvx';
+import { Defu } from 'defu';
 import { silgiFetch } from 'silgi';
+import { useRuntimeConfig } from 'silgi/runtime';
+import { Unimport } from 'unimport';
 import { ProviderName } from 'std-env';
 import { FetchOptions, FetchResponse } from 'ofetch';
 
-interface SilgiRuntimeMethods {
-}
-type CommandType = 'run' | 'prepare' | 'install' | 'dev' | 'init';
-interface SilgiRouterTypes {
-}
-interface DefaultHooks {
-}
-type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-type DeepRequired<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? {
-    [P in keyof T]-?: DeepRequired<T[P]>;
-} : T;
-type Awaitable<T> = T | Promise<T>;
-
 interface SilgiCompatibilityIssue {
     name: string;
     message: string;
@@ -83,279 +67,68 @@ type DeepMerge<A, B> = {
  */
 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: ResolvedServiceDefinition$1;
-    shareds: SilgiRuntimeShareds$1;
-    schemas: Record<string, any>;
-    scannedURIs: Map<string, string>;
-    templates: SilgiTemplate[];
-    hooks: Hookable<SilgiCLIHooks>;
-    hook: SilgiCLI['hooks']['hook'];
-    callHook: SilgiCLI['hooks']['callHook'];
-    addHooks: SilgiCLI['hooks']['addHooks'];
-    storage: Storage;
-    useLocalConfig: typeof useRuntimeConfig;
-    unimport?: Unimport;
-    logger: ConsolaInstance;
-    close: () => Promise<void>;
-    updateConfig: (config: SilgiCLIDynamicConfig) => void | Promise<void>;
-    scanModules: Array<{
-        meta: ModuleMeta$1;
-        module: SilgiModule$1;
-        timings?: Record<string, number | undefined>;
-        entryPath?: string;
-        installed?: boolean;
-        options: Record<string, any>;
-    }>;
-    options: SilgiCLIOptions;
-    _requiredModules: Record<string, boolean>;
-    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
-}
-type SilgiCLIDynamicConfig = Pick<SilgiCLIConfig, 'routeRules'>;
-interface SilgiFrameworkInfo {
-    name?: 'silgi' | (string & {});
-    version?: string;
-}
-/** Build info written to `.output/silgi.json` or `.silgi/dev/silgi.json` */
-interface NitroBuildInfo {
-    date: string;
-    preset: PresetName;
-    framework: SilgiFrameworkInfo;
-    versions: {
-        silgi: string;
-        [key: string]: string;
-    };
-    commands?: {
-        preview?: string;
-        deploy?: string;
-    };
-    dev?: {
-        pid: number;
-        workerAddress: {
-            host: string;
-            port: number;
-            socketPath?: string;
-        };
-    };
-    config?: Partial<PresetOptions>;
-}
-interface ScanFile {
-    context: string;
-    object: {
-        schemas: any;
-        services: any;
-        shareds: any;
-    };
-    path: string;
+interface SilgiRuntimeMethods {
 }
-type TemplateDefaultOptions = Record<string, any>;
-interface SilgiTemplate<Options = TemplateDefaultOptions> {
-    /** resolved output file path (generated) */
-    dst?: string;
-    /** The target filename once the template is copied into the Silgi buildDir */
-    filename?: string;
-    /** An options object that will be accessible within the template via `<% options %>` */
-    options?: Options;
-    /** The resolved path to the source file to be template */
-    src?: string;
-    /** Provided compile option instead of src */
-    where?: 'server' | 'client' | '.silgi';
-    getContents?: (data: {
-        app: SilgiCLI;
-        options: Options;
-    }) => string | Promise<string>;
-    /** Write to filesystem */
-    write?: boolean;
-    skipIfExists?: boolean;
+type CommandType = 'run' | 'prepare' | 'install' | 'dev' | 'init';
+interface SilgiRouterTypes {
 }
-interface ResolvedSilgiTemplate<Options = TemplateDefaultOptions> extends SilgiTemplate<Options> {
-    filename: string;
-    dst: string;
-    modified?: boolean;
+interface DefaultHooks {
 }
+type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type DeepRequired<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+} : T;
+type Awaitable<T> = T | Promise<T>;
 
-interface SilgiCommands {
-}
-interface Commands {
-    name: string;
-    description?: string;
-    group: string;
-    when?: boolean;
-    type: 'function' | 'command';
-    tags?: (keyof SilgiCommands)[] | (string | object)[];
-    getContents: (data: {
-        app: SilgiCLI;
-    }) => string;
-    order?: number;
-}
-interface GenImport {
-    specifier: string;
-    imports: ESMImport | ESMImport[];
-    options?: ESMCodeGenOptions;
-}
-type Framework<T extends PresetName> = T extends 'nitro' ? nitropack_types.NitroApp : T extends 'nuxt' ? nitropack_types.NitroApp : T extends 'h3' ? h3.Router : T extends 'next' ? next.NextApiHandler : never;
-interface DefineFrameworkOptions<T extends PresetName> extends Omit<BuildSilgi$1, 'framework'> {
-    framework: Framework<T>;
+interface ExtendContext {
 }
-
-interface SilgiCLIHooks extends SilgiHooks {
-    /**
-     * Called after Silgi initialization, when the Silgi instance is ready to work.
-     * @param silgi The configured Silgi object
-     * @returns Promise
-     */
-    'ready': (silgi: SilgiCLI) => HookResult;
+interface SilgiRuntimeContext extends Record<string, any> {
+    params?: Record<string, string>;
     /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
+     * Matched router Node
+     *
+     * @experimental The object structure may change in non-major version.
      */
-    'close': (silgi: SilgiCLI) => HookResult;
-    'reload:scan': (path: string, stats?: Stats) => HookResult;
+    matchedRoute?: SilgiRoute;
+    sessions?: Record<string, Session>;
+    clientAddress?: string;
+    source?: any;
+    silgi: {
+        runtimeConfig?: SilgiRuntimeConfig;
+    };
+}
+/**
+ * Bu nitrojs, h3 event or request context.
+ */
+interface SilgiEvent extends Record<string, unknown> {
     /**
-     * Allows extending compatibility checks.
-     * @param compatibility Compatibility object
-     * @param issues Issues to be mapped
-     * @returns Promise
+     * Event context.
      */
-    'kit:compatibility': (compatibility: SilgiCompatibility, issues: SilgiCompatibilityIssues) => HookResult;
+    readonly context: SilgiRuntimeContext;
     /**
-     * Called before Nuxi writes `.nuxt/tsconfig.json` and `.nuxt/nuxt.d.ts`, allowing addition of custom references and declarations in `nuxt.d.ts`, or directly modifying the options in `tsconfig.json`
-     * @param options Objects containing `references`, `declarations`, `tsConfig`
-     * @returns Promise
+     * Incoming HTTP request info.
+     *
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
      */
-    'prepare:types': (options: {
-        references: TSReference[];
-        declarations: string[];
-        tsConfig: TSConfig;
-    }) => HookResult;
-    'before:core.ts': (data: {
-        silgiConfigs: Record<string, any>[];
-        addImportItem: (data: GenImport | GenImport[]) => void;
-        addImportItemType: (data: GenImport | GenImport[]) => void;
-        addBuildFunction: (data: {
-            name: string;
-            params?: string[];
-            custom?: string;
-            where: 'before' | 'after';
-        }[] | {
-            name: string;
-            params?: string[];
-            custom?: string;
-            where: 'before' | 'after';
-        }) => void;
-    }) => HookResult;
-    'after:core.ts': (content: string[]) => HookResult;
-    'before:scan.ts': (data: {
-        services: string[];
-        shareds: string[];
-        routers: string[];
-        schemas: string[];
-        addImportItem: (data: GenImport | GenImport[]) => void;
-        addImportItemType: (data: GenImport | GenImport[]) => void;
-    }) => HookResult;
-    'after:scan.ts': (content: string[]) => HookResult;
-    'before:schema.ts': (options: {
-        addImportItem: (data: GenImport | GenImport[]) => void;
-        addImportItemType: (data: GenImport | GenImport[]) => void;
-        options: {
-            key: string;
-            value: string;
-        }[];
-        runtimeOptions: {
-            key: string;
-            value: string;
-        }[];
-        methods: {
-            key: string;
-            value: string;
-        }[];
-        contexts: {
-            key: string;
-            value: string;
-        }[];
-        actions: {
-            key: string;
-            value: string;
-        }[];
-        shareds: {
-            key: string;
-            value: string;
-        }[];
-        events: {
-            key: string;
-            value: string;
-            /**
-             * If extends is true, it won't be added to the key value interface.
-             * interface SilgiModuleEventsExtends extends SilgiEvent {}
-             */
-            extends?: boolean;
-            isSilgiContext?: boolean;
-        }[];
-        hooks: {
-            key: string;
-            value: string;
-        }[];
-        runtimeHooks: {
-            key: string;
-            value: string;
-        }[];
-    }) => HookResult;
-    'after:schema.ts': (content: string[]) => HookResult;
-    'prepare:configs.ts': (cliOptions: Record<string, any>) => HookResult;
+    readonly req: ServerRequest;
     /**
-     * Called during `SilgiCLI` generation, to allow customizing, modifying or adding new files to the build directory (either virtually or to written to `.nuxt`).
-     * @param app The configured `SilgiCLI` object
-     * @returns Promise
+     * Access to the parsed request URL.
+     *
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/URL)
      */
-    'app:templates': (app: SilgiCLI) => HookResult;
+    readonly url: URL;
     /**
-     * Called after templates are compiled into the [virtual file system](https://nuxt.com/docs/guide/directory-structure/nuxt#virtual-file-system) (vfs).
-     * @param app The configured `SilgiCLI` object
-     * @returns Promise
+     * Prepared HTTP response.
      */
-    'app:templatesGenerated': (app: SilgiCLI, templates: ResolvedSilgiTemplate[], options?: GenerateAppOptions) => HookResult;
-    'scanFiles:done': (app: SilgiCLI) => HookResult;
-    'prepare:commands': (commands: Commands[]) => HookResult;
-    'nextjs:prepare': (data: {
-        config: NextConfig;
-    }) => HookResult;
-}
-type TSReference = {
-    types: string;
-} | {
-    path: string;
-};
-interface SilgiHooks {
-}
-interface GenerateAppOptions {
-    filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
+    readonly res: {
+        status?: number;
+        statusText?: string;
+        readonly headers: Headers;
+    };
 }
 
-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']>>;
-
 /**
  * Main interface containing all route definitions.
  * Example:
@@ -495,7 +268,44 @@ interface ResolvedSchemaDefinition {
     };
 }
 
-type ServiceMethods<Schema extends SilgiSchema$1, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> = {
+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 SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
+    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
+    useRuntimeConfig: typeof useRuntimeConfig;
+    $fetch: typeof silgiFetch;
+    silgi: Silgi;
+}
+interface SilgiRuntimeSharedsExtend {
+}
+interface ExtendShared {
+}
+
+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>;
 };
 /**
@@ -521,17 +331,17 @@ type ServiceHandlerParameters<S, R extends keyof S, M extends keyof S[R]> = S[R]
 /**
  * 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 {
+type ServiceHandlerInput<Schema extends SilgiSchema, 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 {
+type ServiceHandlerOutput<Schema extends SilgiSchema, 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 {
+type ServiceHandlerSource<Schema extends SilgiSchema, Route extends keyof Schema, Method extends keyof Schema[Route]> = Schema[Route][Method] extends {
     source?: infer S;
 } ? InferInput<S> : unknown;
 /**
@@ -540,15 +350,15 @@ type ServiceHandlerSource<Schema extends SilgiSchema$1, Route extends keyof Sche
  * 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>>;
+type ServiceHandler<Schema extends SilgiSchema, 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, event?: SilgiEvent, source?: ServiceHandlerSource<Schema, Route, Method>) => Promise<ServiceHandlerOutput<Schema, Route, Method>> : (input: ServiceHandlerInput<Schema, Route, Method, HiddenParameters>, shared: SilgiRuntimeShareds, event: SilgiEvent, 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> {
+interface ServiceSetup<Schema extends SilgiSchema = SilgiSchema, 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>;
-    routerRule?: RouteConfigService$1;
-    modules?: Partial<SilgiRuntimeActions$1>;
-    storage?: StorageConfig$1<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
+    routerRule?: RouteConfigService;
+    modules?: Partial<SilgiRuntimeActions>;
+    storage?: StorageConfig<ServiceHandlerInput<Schema, Route, Method, HiddenParameters>>;
 }
 /**
  * Represents a fully resolved service definition that maps route paths
@@ -561,8 +371,8 @@ interface ResolvedServiceDefinition {
     [routePath: string]: {
         [method: string]: {
             handler: (...args: any[]) => Promise<any>;
-            modules?: Partial<SilgiRuntimeActions$1>;
-            storage?: StorageConfig$1<any>;
+            modules?: Partial<SilgiRuntimeActions>;
+            storage?: StorageConfig<any>;
         };
     };
 }
@@ -579,105 +389,220 @@ interface SilgiURL {
     queryParams?: Record<string, string>;
 }
 
-type CustomDriverName = string & {
-    _custom?: any;
-};
-interface StorageMounts {
-    [path: string]: {
-        driver: BuiltinDriverName | CustomDriverName;
-        [option: string]: any;
+interface SilgiCLI {
+    _ignore?: Ignore;
+    errors: {
+        type: 'Parser';
+        path?: string;
+    }[];
+    services: ResolvedServiceDefinition;
+    shareds: SilgiRuntimeShareds;
+    schemas: Record<string, any>;
+    scannedURIs: Map<string, string>;
+    templates: SilgiTemplate[];
+    hooks: Hookable<SilgiCLIHooks>;
+    hook: SilgiCLI['hooks']['hook'];
+    callHook: SilgiCLI['hooks']['callHook'];
+    addHooks: SilgiCLI['hooks']['addHooks'];
+    storage: Storage;
+    useLocalConfig: typeof useRuntimeConfig;
+    unimport?: Unimport;
+    logger: ConsolaInstance;
+    close: () => Promise<void>;
+    updateConfig: (config: SilgiCLIDynamicConfig) => void | Promise<void>;
+    scanModules: Array<{
+        meta: ModuleMeta;
+        module: SilgiModule;
+        timings?: Record<string, number | undefined>;
+        entryPath?: string;
+        installed?: boolean;
+        options: Record<string, any>;
+    }>;
+    options: SilgiCLIOptions;
+    _requiredModules: Record<string, boolean>;
+    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
+}
+type SilgiCLIDynamicConfig = Pick<SilgiCLIConfig, 'routeRules'>;
+interface SilgiFrameworkInfo {
+    name?: 'silgi' | (string & {});
+    version?: string;
+}
+/** Build info written to `.output/silgi.json` or `.silgi/dev/silgi.json` */
+interface NitroBuildInfo {
+    date: string;
+    preset: PresetName;
+    framework: SilgiFrameworkInfo;
+    versions: {
+        silgi: string;
+        [key: string]: string;
     };
+    commands?: {
+        preview?: string;
+        deploy?: string;
+    };
+    dev?: {
+        pid: number;
+        workerAddress: {
+            host: string;
+            port: number;
+            socketPath?: string;
+        };
+    };
+    config?: Partial<PresetOptions>;
 }
-interface SilgiStorageBase {
+interface ScanFile {
+    context: string;
+    object: {
+        schemas: any;
+        services: any;
+        shareds: any;
+    };
+    path: string;
 }
-type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
-    options: TransactionOptions;
-    base: 'memory' | keyof SilgiStorageBase;
-    key?: StorageKeyGenerator<TInput>;
-    scope?: 'request' | 'global';
+type TemplateDefaultOptions = Record<string, any>;
+interface SilgiTemplate<Options = TemplateDefaultOptions> {
+    /** resolved output file path (generated) */
+    dst?: string;
+    /** The target filename once the template is copied into the Silgi buildDir */
+    filename?: string;
+    /** An options object that will be accessible within the template via `<% options %>` */
+    options?: Options;
+    /** The resolved path to the source file to be template */
+    src?: string;
+    /** Provided compile option instead of src */
+    where?: 'server' | 'client' | '.silgi';
+    getContents?: (data: {
+        app: SilgiCLI;
+        options: Options;
+    }) => string | Promise<string>;
+    /** Write to filesystem */
+    write?: boolean;
+    skipIfExists?: boolean;
 }
-interface StorageKeyParams<TInput = unknown> {
-    url: SilgiURL;
-    input: TInput;
-    requestId?: string;
-    keyGenerator?: StorageKeyGenerator<TInput>;
-    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
+interface ResolvedSilgiTemplate<Options = TemplateDefaultOptions> extends SilgiTemplate<Options> {
+    filename: string;
+    dst: string;
+    modified?: boolean;
 }
 
-interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
-    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
-    useRuntimeConfig: typeof useRuntimeConfig;
-    $fetch: typeof silgiFetch;
-    silgi: Silgi;
+interface SilgiRuntimeActions {
 }
-interface SilgiRuntimeSharedsExtend {
+interface SilgiModuleOptions {
 }
-interface ExtendShared {
+interface SilgiRuntimeOptions {
 }
-
-type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
-type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiRuntimeMethods | StandardHTTPMethod : StandardHTTPMethod;
-interface SilgiRoute {
-    route: string;
-    method?: HTTPMethod;
-    service: ServiceSetup;
-    schema: ResolvedSchemaDefinition;
+type SilgiModuleInput = (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false);
+interface SilgiCompatibility {
+    /**
+     * Required silgi version in semver format.
+     * @example `^3.2.0` or `>=3.13.0`.
+     */
+    silgi?: string;
 }
-interface Silgi {
-    router: RouterContext<SilgiRoute>;
-    routerPrefixs: string[];
-    schemas: ResolvedSchemaDefinition;
-    services: ResolvedServiceDefinition;
-    shared: SilgiRuntimeShareds;
-    plugins: SilgiAppPlugin[];
-    framework?: {
-        nitro?: NitroApp;
+interface ModuleMeta {
+    /** Module name. */
+    name?: string;
+    /** Module description. */
+    description?: string;
+    /** Module author. */
+    author?: string;
+    /** Module license. */
+    license?: string;
+    /** Module version. */
+    version?: string;
+    /**
+     * The configuration key used within `silgi.config` for this module's options.
+     * For example, `@silgijs/axios` uses `axios`.
+     */
+    configKey?: string;
+    /**
+     * Constraints for the versions of silgi or features this module requires.
+     */
+    compatibility?: SilgiCompatibility;
+    /**
+     * @private
+     */
+    _modules?: {
+        [key: string]: string;
     };
-    _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;
+    /**
+     * @private
+     */
+    _packageName?: string;
+    cliToRuntimeOptionsKeys?: string[];
+    readonly afterDependencies?: ReadonlyArray<string>;
+    readonly beforeDependencies?: ReadonlyArray<string>;
+    readonly requiredDependencies?: ReadonlyArray<string>;
+    [key: string]: unknown;
 }
-interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRuntimeOptions> {
-    options: DeepPartial<SilgiOptions>;
+interface ResolvedModuleMeta extends ModuleMeta {
+    configKey: string;
+    name: string;
 }
-interface BuildSilgi {
-    framework?: {
-        nitro?: NitroApp;
+type ModuleHookContext = Readonly<{
+    event?: SilgiEvent;
+    url: SilgiURL;
+    input?: unknown;
+    result?: unknown;
+    route?: SilgiRoute;
+    error?: Error;
+    success?: boolean;
+    cached?: boolean;
+}> & {
+    hookContext?: {
+        earlyReturnValue: any | false;
     };
-    modules?: Partial<SilgiRuntimeOptions>;
-    options?: Partial<SilgiOptions>;
+};
+/** The options received.  */
+type ModuleOptionsCustom = Record<string, any>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ResolvedModuleOptions<TOptions extends ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions>> = Prettify<Defu<Partial<TOptions>, [
+    Partial<TOptions>,
+    TOptionsDefaults
+]>>;
+interface ModuleDefinition<TOptions extends ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions>, TWith extends boolean> {
+    meta?: ModuleMeta;
+    defaults?: TOptionsDefaults | ((silgi: SilgiCLI) => Awaitable<TOptionsDefaults>);
+    hooks?: Partial<SilgiCLIHooks>;
+    setup?: (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: SilgiCLI & SilgiModuleOptions) => ModuleSetupReturn;
 }
-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 ModuleSetupInstallResult {
+    /**
+     * Timing information for the initial setup
+     */
+    timings?: {
+        /** Total time took for module setup in ms */
+        setup?: number;
+        [key: string]: number | undefined;
+    };
+}
+type ModuleSetupReturn = Awaitable<false | void | ModuleSetupInstallResult>;
+interface SilgiModule<TOptions extends ModuleOptionsCustom = ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions> = Partial<TOptions>, TWith extends boolean = false> {
+    (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: SilgiCLI): ModuleSetupReturn;
+    getOptions?: (inlineOptions?: Partial<TOptions>, silgi?: SilgiCLI) => Promise<TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions>;
+    getMeta?: () => Promise<ModuleMeta>;
+}
+
+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 SilgiAppPlugin {
     (silgi: Silgi): Promise<void> | void;
@@ -743,151 +668,225 @@ interface SilgiOptions {
     [key: string]: any;
 }
 
-interface ExtendContext {
+type StandardHTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+type HTTPMethod = SilgiRuntimeMethods extends Record<string, any> ? keyof SilgiRuntimeMethods | StandardHTTPMethod : StandardHTTPMethod;
+interface SilgiRoute {
+    route: string;
+    method?: HTTPMethod;
+    service: ServiceSetup;
+    schema: ResolvedSchemaDefinition;
 }
-interface SilgiRuntimeContext extends Record<string, any> {
-    params?: Record<string, string>;
-    /**
-     * Matched router Node
-     *
-     * @experimental The object structure may change in non-major version.
-     */
-    matchedRoute?: SilgiRoute;
-    sessions?: Record<string, Session>;
-    clientAddress?: string;
-    source?: any;
-    silgi: {
-        runtimeConfig?: SilgiRuntimeConfig;
+interface Silgi {
+    router: RouterContext<SilgiRoute>;
+    routerPrefixs: string[];
+    schemas: ResolvedSchemaDefinition;
+    services: ResolvedServiceDefinition;
+    shared: SilgiRuntimeShareds;
+    plugins: SilgiAppPlugin[];
+    framework?: {
+        nitro?: NitroApp;
     };
-}
-/**
- * Bu nitrojs, h3 event or request context.
- */
-interface SilgiEvent extends Record<string, unknown> {
-    /**
-     * Event context.
-     */
-    readonly context: SilgiRuntimeContext;
-    /**
-     * Incoming HTTP request info.
-     *
-     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
-     */
-    readonly req: ServerRequest;
-    /**
-     * Access to the parsed request URL.
-     *
-     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/URL)
-     */
-    readonly url: URL;
-    /**
-     * Prepared HTTP response.
-     */
-    readonly res: {
-        status?: number;
-        statusText?: string;
-        readonly headers: Headers;
+    _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?: {
+        nitro?: NitroApp;
     };
+    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 SilgiRuntimeActions {
+interface SilgiCommands {
 }
-interface SilgiModuleOptions {
+interface Commands {
+    name: string;
+    description?: string;
+    group: string;
+    when?: boolean;
+    type: 'function' | 'command';
+    tags?: (keyof SilgiCommands)[] | (string | object)[];
+    getContents: (data: {
+        app: SilgiCLI;
+    }) => string;
+    order?: number;
 }
-interface SilgiRuntimeOptions {
+interface GenImport {
+    specifier: string;
+    imports: ESMImport | ESMImport[];
+    options?: ESMCodeGenOptions;
 }
-type SilgiModuleInput = (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false);
-interface SilgiCompatibility {
+type Framework<T extends PresetName> = T extends 'nitro' ? nitropack_types.NitroApp : T extends 'nuxt' ? nitropack_types.NitroApp : T extends 'h3' ? h3.Router : T extends 'next' ? next.NextApiHandler : never;
+interface DefineFrameworkOptions<T extends PresetName> extends Omit<BuildSilgi, 'framework'> {
+    framework: Framework<T>;
+}
+
+interface SilgiCLIHooks extends SilgiHooks {
     /**
-     * Required silgi version in semver format.
-     * @example `^3.2.0` or `>=3.13.0`.
+     * Called after Silgi initialization, when the Silgi instance is ready to work.
+     * @param silgi The configured Silgi object
+     * @returns Promise
      */
-    silgi?: string;
-}
-interface ModuleMeta {
-    /** Module name. */
-    name?: string;
-    /** Module description. */
-    description?: string;
-    /** Module author. */
-    author?: string;
-    /** Module license. */
-    license?: string;
-    /** Module version. */
-    version?: string;
+    'ready': (silgi: SilgiCLI) => HookResult;
     /**
-     * The configuration key used within `silgi.config` for this module's options.
-     * For example, `@silgijs/axios` uses `axios`.
+     * Called when silgi instance is gracefully closing.
+     * @param silgi The configured silgi object
+     * @returns Promise
      */
-    configKey?: string;
+    'close': (silgi: SilgiCLI) => HookResult;
+    'reload:scan': (path: string, stats?: Stats) => HookResult;
     /**
-     * Constraints for the versions of silgi or features this module requires.
+     * Allows extending compatibility checks.
+     * @param compatibility Compatibility object
+     * @param issues Issues to be mapped
+     * @returns Promise
      */
-    compatibility?: SilgiCompatibility;
+    'kit:compatibility': (compatibility: SilgiCompatibility, issues: SilgiCompatibilityIssues) => HookResult;
     /**
-     * @private
+     * Called before Nuxi writes `.nuxt/tsconfig.json` and `.nuxt/nuxt.d.ts`, allowing addition of custom references and declarations in `nuxt.d.ts`, or directly modifying the options in `tsconfig.json`
+     * @param options Objects containing `references`, `declarations`, `tsConfig`
+     * @returns Promise
      */
-    _modules?: {
-        [key: string]: string;
-    };
+    'prepare:types': (options: {
+        references: TSReference[];
+        declarations: string[];
+        tsConfig: TSConfig;
+    }) => HookResult;
+    'before:core.ts': (data: {
+        silgiConfigs: Record<string, any>[];
+        addImportItem: (data: GenImport | GenImport[]) => void;
+        addImportItemType: (data: GenImport | GenImport[]) => void;
+        addBuildFunction: (data: {
+            name: string;
+            params?: string[];
+            custom?: string;
+            where: 'before' | 'after';
+        }[] | {
+            name: string;
+            params?: string[];
+            custom?: string;
+            where: 'before' | 'after';
+        }) => void;
+    }) => HookResult;
+    'after:core.ts': (content: string[]) => HookResult;
+    'before:scan.ts': (data: {
+        services: string[];
+        shareds: string[];
+        routers: string[];
+        schemas: string[];
+        addImportItem: (data: GenImport | GenImport[]) => void;
+        addImportItemType: (data: GenImport | GenImport[]) => void;
+    }) => HookResult;
+    'after:scan.ts': (content: string[]) => HookResult;
+    'before:schema.ts': (options: {
+        addImportItem: (data: GenImport | GenImport[]) => void;
+        addImportItemType: (data: GenImport | GenImport[]) => void;
+        options: {
+            key: string;
+            value: string;
+        }[];
+        runtimeOptions: {
+            key: string;
+            value: string;
+        }[];
+        methods: {
+            key: string;
+            value: string;
+        }[];
+        contexts: {
+            key: string;
+            value: string;
+        }[];
+        actions: {
+            key: string;
+            value: string;
+        }[];
+        shareds: {
+            key: string;
+            value: string;
+        }[];
+        events: {
+            key: string;
+            value: string;
+            /**
+             * If extends is true, it won't be added to the key value interface.
+             * interface SilgiModuleEventsExtends extends SilgiEvent {}
+             */
+            extends?: boolean;
+            isSilgiContext?: boolean;
+        }[];
+        hooks: {
+            key: string;
+            value: string;
+        }[];
+        runtimeHooks: {
+            key: string;
+            value: string;
+        }[];
+    }) => HookResult;
+    'after:schema.ts': (content: string[]) => HookResult;
+    'prepare:configs.ts': (cliOptions: Record<string, any>) => HookResult;
     /**
-     * @private
+     * Called during `SilgiCLI` generation, to allow customizing, modifying or adding new files to the build directory (either virtually or to written to `.nuxt`).
+     * @param app The configured `SilgiCLI` object
+     * @returns Promise
      */
-    _packageName?: string;
-    cliToRuntimeOptionsKeys?: string[];
-    readonly afterDependencies?: ReadonlyArray<string>;
-    readonly beforeDependencies?: ReadonlyArray<string>;
-    readonly requiredDependencies?: ReadonlyArray<string>;
-    [key: string]: unknown;
-}
-interface ResolvedModuleMeta extends ModuleMeta {
-    configKey: string;
-    name: string;
-}
-type ModuleHookContext = Readonly<{
-    event?: SilgiEvent;
-    url: SilgiURL;
-    input?: unknown;
-    result?: unknown;
-    route?: SilgiRoute;
-    error?: Error;
-    success?: boolean;
-    cached?: boolean;
-}> & {
-    hookContext?: {
-        earlyReturnValue: any | false;
-    };
-};
-/** The options received.  */
-type ModuleOptionsCustom = Record<string, any>;
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type ResolvedModuleOptions<TOptions extends ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions>> = Prettify<Defu<Partial<TOptions>, [
-    Partial<TOptions>,
-    TOptionsDefaults
-]>>;
-interface ModuleDefinition<TOptions extends ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions>, TWith extends boolean> {
-    meta?: ModuleMeta;
-    defaults?: TOptionsDefaults | ((silgi: SilgiCLI) => Awaitable<TOptionsDefaults>);
-    hooks?: Partial<SilgiCLIHooks>;
-    setup?: (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: SilgiCLI & SilgiModuleOptions) => ModuleSetupReturn;
-}
-interface ModuleSetupInstallResult {
+    'app:templates': (app: SilgiCLI) => HookResult;
     /**
-     * Timing information for the initial setup
+     * Called after templates are compiled into the [virtual file system](https://nuxt.com/docs/guide/directory-structure/nuxt#virtual-file-system) (vfs).
+     * @param app The configured `SilgiCLI` object
+     * @returns Promise
      */
-    timings?: {
-        /** Total time took for module setup in ms */
-        setup?: number;
-        [key: string]: number | undefined;
-    };
+    'app:templatesGenerated': (app: SilgiCLI, templates: ResolvedSilgiTemplate[], options?: GenerateAppOptions) => HookResult;
+    'scanFiles:done': (app: SilgiCLI) => HookResult;
+    'prepare:commands': (commands: Commands[]) => HookResult;
+    'nextjs:prepare': (data: {
+        config: NextConfig;
+    }) => HookResult;
 }
-type ModuleSetupReturn = Awaitable<false | void | ModuleSetupInstallResult>;
-interface SilgiModule<TOptions extends ModuleOptionsCustom = ModuleOptionsCustom, TOptionsDefaults extends Partial<TOptions> = Partial<TOptions>, TWith extends boolean = false> {
-    (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: SilgiCLI): ModuleSetupReturn;
-    getOptions?: (inlineOptions?: Partial<TOptions>, silgi?: SilgiCLI) => Promise<TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions>;
-    getMeta?: () => Promise<ModuleMeta>;
+type TSReference = {
+    types: string;
+} | {
+    path: string;
+};
+interface SilgiHooks {
+}
+interface GenerateAppOptions {
+    filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
 
 type SilgiPreset = (SilgiCLIConfig & {
@@ -915,14 +914,14 @@ interface SilgiCLIOptions extends PresetOptions {
         command?: string;
     };
     commandType: CommandType;
-    commands: Commands$1[];
+    commands: Commands[];
     schemaVendor: Schema | Schema[];
     environments: DotenvOptions$1[];
     activeEnvironment: 'prod' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
-    envOptions: EnvOptions$1;
-    runtimeConfig: SilgiRuntimeConfig$1;
+    envOptions: EnvOptions;
+    runtimeConfig: SilgiRuntimeConfig;
     storages: string[];
-    hooks: NestedHooks<SilgiCLIHooks$1>;
+    hooks: NestedHooks<SilgiCLIHooks>;
     plugins: {
         path: string;
         packageImport: string;
@@ -946,8 +945,8 @@ interface SilgiCLIOptions extends PresetOptions {
             safeList: string[][];
         };
     };
-    storage: StorageMounts$1;
-    devStorage: StorageMounts$1;
+    storage: StorageMounts;
+    devStorage: StorageMounts;
     workspaceDir: string;
     rootDir: string;
     srcDir: string;
@@ -970,7 +969,7 @@ interface SilgiCLIOptions extends PresetOptions {
          * ]
          * ```
          */
-        templates: SilgiTemplate$1<any>[];
+        templates: SilgiTemplate<any>[];
     };
     modulesDir: string[];
     output: {
@@ -1009,7 +1008,7 @@ interface SilgiCLIOptions extends PresetOptions {
     devServer: {
         watch: string[];
     };
-    framework: SilgiFrameworkInfo$1;
+    framework: SilgiFrameworkInfo;
     /**
      * More customizable than `ignorePrefix`: all files matching glob patterns specified inside the `ignore` array will be ignored in building.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.37.38",
+  "version": "0.37.40",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -108,7 +108,6 @@
     "dotenv": "^16.5.0",
     "escape-string-regexp": "^5.0.0",
     "exsolve": "^1.0.5",
-    "globby": "^14.1.0",
     "hookable": "^5.5.3",
     "ignore": "^7.0.4",
     "klona": "^2.0.6",
@@ -128,6 +127,7 @@
     "semver": "^7.7.1",
     "srvx": "^0.6.0",
     "std-env": "^3.9.0",
+    "tinyglobby": "^0.2.13",
     "ufo": "^1.6.1",
     "unadapter": "^0.1.2",
     "unctx": "^2.4.1",