silgi 0.36.18 → 0.37.1

package/dist/types/index.d.mts

@@ -2,7 +2,7 @@ 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';
@@ -11,7 +11,7 @@ import { ResolvedServiceDefinition as ResolvedServiceDefinition$1, SilgiRuntimeS
 import { Adapter, TablesSchema, InferModelTypes } from 'unadapter/types';
 import { UnimportPluginOptions } from 'unimport/unplugin';
 import * as h3 from 'h3';
-import { H3Event, HTTPMethod as HTTPMethod$1, Session } 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,12 +21,12 @@ import { Stats } from 'node:fs';
 import { ESMImport, ESMCodeGenOptions } from 'knitwork';
 import { Unimport } from 'unimport';
 import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { ProviderName } from 'std-env';
 import { ServerRequest } from 'srvx';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { NitroApp } from 'nitropack';
 import { RouterContext } from 'rou3';
 import { silgiFetch } from 'silgi';
+import { ProviderName } from 'std-env';
 import { FetchOptions, FetchResponse } from 'ofetch';
 
 interface SilgiCompatibilityIssue {
@@ -321,6 +321,60 @@ interface GenerateAppOptions {
     filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
 
+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;
+}
+
+interface CapturedErrorContext {
+    event?: SilgiEvent;
+    [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;
+    'request:on': (event: SilgiEvent) => HookResult;
+    'fetch:before': (context: ModuleHookContext) => HookResult;
+    'fetch:after': (context: ModuleHookContext) => HookResult;
+    'fetch:error': (context: ModuleHookContext) => HookResult;
+    'fetch:finally': (context: Omit<ModuleHookContext, 'event'>) => HookResult;
+    'error': CaptureError;
+}
+
 type ServiceMethods<Schema extends SilgiSchema$1, Path extends keyof Schema, Resolved extends boolean = false, HiddenParameters extends boolean = false> = {
     [M in keyof Schema[Path]]?: ServiceSetup<Schema, Path, M, Resolved, HiddenParameters>;
 };
@@ -404,440 +458,68 @@ interface SilgiURL {
     queryParams?: Record<string, string>;
 }
 
-interface SilgiRuntimeActions {
-}
-interface SilgiModuleOptions {
-}
-interface SilgiRuntimeOptions {
-}
-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 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;
+type CustomDriverName = string & {
+    _custom?: any;
+};
+interface StorageMounts {
+    [path: string]: {
+        driver: BuiltinDriverName | CustomDriverName;
+        [option: string]: any;
     };
-    /**
-     * @private
-     */
-    _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<{
-    url: SilgiURL;
-    input?: unknown;
-    result?: unknown;
-    modules?: SilgiRuntimeActions;
-    error?: Error;
-    success?: boolean;
-    cached?: boolean;
-}>;
-/** 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 SilgiStorageBase {
 }
-interface ModuleSetupInstallResult {
-    /**
-     * Timing information for the initial setup
-     */
-    timings?: {
-        /** Total time took for module setup in ms */
-        setup?: number;
-        [key: string]: number | undefined;
-    };
+type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
+interface StorageConfig<TInput> {
+    options: TransactionOptions;
+    base: 'memory' | keyof SilgiStorageBase;
+    key?: StorageKeyGenerator<TInput>;
+    scope?: 'request' | 'global';
 }
-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>;
+interface StorageKeyParams<TInput = unknown> {
+    url: SilgiURL;
+    input: TInput;
+    requestId?: string;
+    keyGenerator?: StorageKeyGenerator<TInput>;
+    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
 }
 
-interface SilgiRuntimeMethods {
-}
-type CommandType = 'run' | 'prepare' | 'install' | 'dev' | 'init';
-interface SilgiRouterTypes {
-}
-interface DefaultHooks {
+interface SilgiRuntimeConfig {
 }
-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>;
-declare global {
-    var $silgiStatus: CommandType;
-    var _silgi_runtime: SilgiRuntimeOptions;
-    namespace NodeJS {
-        interface Global {
-            $silgiStatus: CommandType;
-            _silgi_runtime: SilgiRuntimeOptions;
-        }
-    }
-    var __nitro__: {
-        useRuntimeConfig?: <T extends NitroRuntimeConfig = NitroRuntimeConfig>(event?: H3Event) => T;
+interface SilgiOptions {
+    consolaOptions?: Partial<ConsolaOptions>;
+    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;
 }
 
-type SilgiPreset = (SilgiCLIConfig & {
-    _meta?: SilgiPresetMeta;
-}) | (() => SilgiCLIConfig & {
-    _meta?: SilgiPresetMeta;
-});
-interface SilgiPresetMeta {
-    url: string;
-    name: string;
-    stdName?: ProviderName;
-    aliases?: string[];
-    static?: boolean;
-    compatibilityDate?: DateString;
+/**
+ * Main interface containing all route definitions.
+ * Example:
+ * {
+ *   "/api/blueSpace/basket/getBook": { ... }
+ * }
+ */
+interface Routers {
 }
-
-type Schema = 'zod' | 'valibot' | 'arkType' | 'typebox';
 /**
- * SilgiCLI normalized options (silgi.options)
- */
-interface SilgiCLIOptions extends PresetOptions {
-    _config: SilgiCLIConfig;
-    _c12: ResolvedConfig<SilgiCLIConfig> | ConfigWatcher<SilgiCLIConfig>;
-    _cli?: {
-        command?: string;
-    };
-    commandType: CommandType;
-    commands: Commands$1[];
-    schemaVendor: Schema | Schema[];
-    environments: DotenvOptions$1[];
-    activeEnvironment: 'prod' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
-    envOptions: EnvOptions$1;
-    runtimeConfig: SilgiRuntimeConfig$1 & {
-        [key: string]: any;
-    };
-    storages: string[];
-    hooks: NestedHooks<SilgiCLIHooks$1>;
-    plugins: {
-        path: string;
-        packageImport: string;
-    }[];
-    baseURL: string;
-    compatibilityDate: CompatibilityDates;
-    modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
-    _modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
-    isPreparingModules: boolean;
-    debug: true | {
-        command?: boolean;
-        install?: boolean;
-    };
-    preset: PresetName;
-    static: boolean;
-    logLevel: LogLevel;
-    appConfig: AppConfig;
-    appConfigFiles: string[];
-    codegen: {
-        env: {
-            safeList: string[][];
-        };
-    };
-    storage: StorageMounts$1;
-    devStorage: StorageMounts$1;
-    workspaceDir: string;
-    rootDir: string;
-    srcDir: string;
-    migrationDir: string;
-    scanDirs: string[];
-    build: {
-        dir: string;
-        typesDir: string;
-        /**
-         * It is recommended to use `addTemplate` from `@nuxt/kit` instead of this option.
-         *
-         *
-         * @example
-         * ```js
-         * templates: [
-         *   {
-         *     src: '~/modules/support/plugin.js', // `src` can be absolute or relative
-         *     dst: 'support.js', // `dst` is relative to project `.nuxt` dir
-         *   }
-         * ]
-         * ```
-         */
-        templates: SilgiTemplate$1<any>[];
-    };
-    modulesDir: string[];
-    output: {
-        dir: string;
-        serverDir: string;
-        publicDir: string;
-    };
-    serverDir: string;
-    clientDir: string;
-    silgi: {
-        /**
-         * @default "{serverDir}/silgi"
-         */
-        serverDir: string;
-        clientDir: string;
-        /**
-         * @default "{serverDir}/public"
-         */
-        publicDir: string;
-        /**
-         * @default "{silgi.serverDir}/utils"
-         */
-        utilsDir: string;
-        /**
-         * @default "{silgi.serverDir}/types"
-         */
-        typesDir: string;
-        /**
-         * @default "{silgi.serverDir}/vfs"
-         */
-        vfsDir: string;
-    };
-    imports: UnimportPluginOptions | false;
-    watchOptions: ChokidarOptions;
-    nodeModulesDirs: string[];
-    devServer: {
-        watch: string[];
-    };
-    framework: SilgiFrameworkInfo$1;
-    /**
-     * More customizable than `ignorePrefix`: all files matching glob patterns specified inside the `ignore` array will be ignored in building.
-     *
-     * @default ["**\/*.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}",".nuxt/analyze",".nuxt","**\/-*.*"]
-     */
-    ignore: Array<string>;
-    /**
-     * Whether Nuxt is running in development mode.
-     *
-     * Normally, you should not need to set this.
-     *
-     * @default false
-     */
-    dev: boolean;
-    /**
-     * jiti with stub mode
-     * @default false
-     */
-    stub: boolean;
-    /**
-     * Whether your app is being unit tested.
-     *
-     * @default false
-     */
-    test: boolean;
-    extensions: string[];
-    future: {
-        /**
-         * This enables 'Bundler' module resolution mode for TypeScript, which is the recommended setting for frameworks like Nuxt and Vite.
-         *
-         * It improves type support when using modern libraries with `exports`.
-         * You can set it to false to use the legacy 'Node' mode, which is the default for TypeScript.
-         *
-         * @default true
-         *
-         * @see [TypeScript PR implementing `bundler` module resolution](https://github.com/microsoft/TypeScript/pull/51669)
-         */
-        typescriptBundlerResolution: boolean;
-    };
-    typescript: {
-        /**
-         * TypeScript comes with certain checks to give you more safety and analysis of your program. Once you’ve converted your codebase to TypeScript, you can start enabling these checks for greater safety. [Read More](https://www.typescriptlang.org/docs/handbook/migrating-from-javascript.html#getting-stricter-checks)
-         *
-         * @default true
-         */
-        strict: boolean;
-        /**
-         * Modules to generate deep aliases for within `compilerOptions.paths`. This does not yet support subpaths. It may be necessary when using Nuxt within a pnpm monorepo with `shamefully-hoist=false`.
-         *
-         * @default ["nitro/types","nitro/runtime","defu","h3","consola","ofetch","@unhead/vue","@nuxt/devtools","vue","@vue/runtime-core","@vue/compiler-sfc","vue-router","vue-router/auto-routes","unplugin-vue-router/client","@nuxt/schema","nuxt"]
-         */
-        hoist: Array<string>;
-        /**
-         * Include parent workspace in the Nuxt project. Mostly useful for themes and module authors.
-         *
-         * @default false
-         */
-        includeWorkspace: boolean;
-        /**
-         * Enable build-time type checking.
-         *
-         * If set to true, this will type check in development. You can restrict this to build-time type checking by setting it to `build`. Requires to install `typescript` and `vue-tsc` as dev dependencies.
-         *
-         * @default false
-         *
-         * @see [Nuxt TypeScript docs](https://nuxt.com/docs/guide/concepts/typescript)
-         */
-        typeCheck: boolean | 'build';
-        /**
-         * You can extend generated `.nuxt/tsconfig.json` using this option.
-         *
-         */
-        tsConfig: TSConfig;
-        /**
-         * Generate a `*.vue` shim.
-         *
-         * We recommend instead letting the [official Vue extension](https://marketplace.visualstudio.com/items?itemName=Vue.volar) generate accurate types for your components.
-         * Note that you may wish to set this to `true` if you are using other libraries, such as ESLint, that are unable to understand the type of `.vue` files.
-         *
-         * @default false
-         */
-        shim: boolean;
-        /**
-         * @default "types/silgi.tsconfig.json"
-         */
-        tsconfigPath: string;
-        /**
-         * @default true
-         */
-        generateTsConfig: boolean;
-        /**
-         * @default ['silgiTypes']
-         */
-        customConditions: string[];
-        /**
-         * Enable generating runtime configuration types.
-         *
-         * @default true
-         */
-        generateRuntimeConfigTypes: boolean;
-        /**
-         * @default false
-         * Behavior of import paths in auto-generated silgi files
-         */
-        removeFileExtension: boolean;
-    };
-    alias: Record<string, string>;
-    /**
-     * @default ['silgi']
-     */
-    conditions: string[];
-    /**
-     * Pass options directly to `node-ignore` (which is used by Nuxt to ignore files).
-     *
-     *
-     * @see [node-ignore](https://github.com/kaelzhang/node-ignore)
-     *
-     * @example
-     * ```js
-     * ignoreOptions: {
-     *   ignorecase: false
-     * }
-     * ```
-     */
-    ignoreOptions: Options;
-    installPackages: Record<'dependencies' | 'devDependencies', Record<string, string>>;
-    apiFul: ApifulConfig;
-    adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
-}
-/**
- * Silgi input config (silgi.config)
- */
-interface SilgiCLIConfig extends DeepPartial<Omit<SilgiCLIOptions, 'preset' | 'compatibilityDate' | '_config' | '_c12' | 'consola'>>, C12InputConfig<SilgiCLIConfig>, Partial<SilgiModuleOptions> {
-    preset?: PresetNameInput;
-    extends?: string | string[] | SilgiPreset;
-    compatibilityDate?: CompatibilityDateSpec;
-}
-interface AppConfig {
-    [key: string]: any;
-}
-interface LoadConfigOptions {
-    watch?: boolean;
-    c12?: WatchConfigOptions;
-    compatibilityDate?: CompatibilityDateSpec;
-    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 SilgiAppPlugin {
-    (silgi: Silgi): Promise<void> | void;
-}
-
-interface CapturedErrorContext {
-    event?: SilgiEvent;
-    [key: string]: unknown;
-}
-type CaptureError = (silgi: Silgi, error: Error, context: CapturedErrorContext) => void;
-
-/**
- * Main interface containing all route definitions.
- * Example:
- * {
- *   "/api/blueSpace/basket/getBook": { ... }
- * }
- */
-interface Routers {
-}
-/**
- * Extracts the prefix (first segment) from a URL, including the leading slash.
- * @example ExtractPrefix<'/api/blueSpace/basket'> // '/api'
+ * 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;
 /**
@@ -953,208 +635,527 @@ type MethodSchemas<PathParamsStr extends string = ''> = {
 interface ResolvedSchema {
     [routePath: string]: MethodSchemas<string>;
 }
-/**
- * Represents a schema definition that has been fully resolved,
- * typically after processing and validating all schema components.
- */
-interface ResolvedSchemaDefinition {
-    [key: string]: {
-        [method: string]: BaseMethodSchema;
+/**
+ * Represents a schema definition that has been fully resolved,
+ * typically after processing and validating all schema components.
+ */
+interface ResolvedSchemaDefinition {
+    [key: string]: {
+        [method: string]: BaseMethodSchema;
+    };
+}
+
+interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
+    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
+    runtimeConfig: SilgiRuntimeConfig;
+    $fetch: typeof silgiFetch;
+    silgi: Silgi;
+}
+interface SilgiRuntimeSharedsExtend {
+}
+interface ExtendShared {
+}
+
+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;
+    setup: ServiceSetup;
+    schema: ResolvedSchemaDefinition;
+}
+interface Silgi {
+    router: RouterContext<SilgiRoute>;
+    routerPrefixs: string[];
+    schemas: ResolvedSchemaDefinition;
+    services: ResolvedServiceDefinition;
+    shared: SilgiRuntimeShareds;
+    plugins: SilgiAppPlugin[];
+    framework?: {
+        nitro?: NitroApp;
+    };
+    _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 ExtendContext {
+}
+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;
+}
+/**
+ * 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;
+    };
+}
+
+interface SilgiRuntimeActions {
+}
+interface SilgiModuleOptions {
+}
+interface SilgiRuntimeOptions {
+}
+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 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;
     };
+    /**
+     * @private
+     */
+    _packageName?: string;
+    cliToRuntimeOptionsKeys?: string[];
+    readonly afterDependencies?: ReadonlyArray<string>;
+    readonly beforeDependencies?: ReadonlyArray<string>;
+    readonly requiredDependencies?: ReadonlyArray<string>;
+    [key: string]: unknown;
 }
-
-type CustomDriverName = string & {
-    _custom?: any;
-};
-interface StorageMounts {
-    [path: string]: {
-        driver: BuiltinDriverName | CustomDriverName;
-        [option: string]: any;
-    };
+interface ResolvedModuleMeta extends ModuleMeta {
+    configKey: string;
+    name: string;
 }
-interface SilgiStorageBase {
+type ModuleHookContext = Readonly<{
+    event?: SilgiEvent;
+    url: SilgiURL;
+    input?: unknown;
+    result?: unknown;
+    route: SilgiRoute;
+    error?: Error;
+    success?: boolean;
+    cached?: boolean;
+}>;
+/** 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 StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
-    options: TransactionOptions;
-    base: 'memory' | keyof SilgiStorageBase;
-    key?: StorageKeyGenerator<TInput>;
-    scope?: 'request' | 'global';
+interface ModuleSetupInstallResult {
+    /**
+     * Timing information for the initial setup
+     */
+    timings?: {
+        /** Total time took for module setup in ms */
+        setup?: number;
+        [key: string]: number | undefined;
+    };
 }
-interface StorageKeyParams<TInput = unknown> {
-    url: SilgiURL;
-    input: TInput;
-    requestId?: string;
-    keyGenerator?: StorageKeyGenerator<TInput>;
-    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
+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>;
 }
 
-interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
-    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
-    runtimeConfig: SilgiRuntimeConfig;
-    $fetch: typeof silgiFetch;
-    silgi: Silgi;
+interface SilgiRuntimeMethods {
 }
-interface SilgiRuntimeSharedsExtend {
+type CommandType = 'run' | 'prepare' | 'install' | 'dev' | 'init';
+interface SilgiRouterTypes {
 }
-interface ExtendShared {
+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>;
+declare global {
+    var $silgiStatus: CommandType;
+    var _silgi_runtime: SilgiRuntimeOptions;
+    namespace NodeJS {
+        interface Global {
+            $silgiStatus: CommandType;
+            _silgi_runtime: SilgiRuntimeOptions;
+        }
+    }
+    var __nitro__: {
+        useRuntimeConfig?: <T extends NitroRuntimeConfig = NitroRuntimeConfig>(event?: H3Event) => T;
+        [key: string]: any;
+    };
 }
 
-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;
-    setup: ServiceSetup;
-    schema: ResolvedSchemaDefinition;
+type SilgiPreset = (SilgiCLIConfig & {
+    _meta?: SilgiPresetMeta;
+}) | (() => SilgiCLIConfig & {
+    _meta?: SilgiPresetMeta;
+});
+interface SilgiPresetMeta {
+    url: string;
+    name: string;
+    stdName?: ProviderName;
+    aliases?: string[];
+    static?: boolean;
+    compatibilityDate?: DateString;
 }
-interface Silgi {
-    router: RouterContext<SilgiRoute>;
-    routerPrefixs: string[];
-    schemas: ResolvedSchemaDefinition;
-    services: ResolvedServiceDefinition;
-    shared: SilgiRuntimeShareds;
-    plugins: SilgiAppPlugin[];
-    framework?: {
-        nitro?: NitroApp;
+
+type Schema = 'zod' | 'valibot' | 'arkType' | 'typebox';
+/**
+ * SilgiCLI normalized options (silgi.options)
+ */
+interface SilgiCLIOptions extends PresetOptions {
+    _config: SilgiCLIConfig;
+    _c12: ResolvedConfig<SilgiCLIConfig> | ConfigWatcher<SilgiCLIConfig>;
+    _cli?: {
+        command?: string;
+    };
+    commandType: CommandType;
+    commands: Commands$1[];
+    schemaVendor: Schema | Schema[];
+    environments: DotenvOptions$1[];
+    activeEnvironment: 'prod' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
+    envOptions: EnvOptions$1;
+    runtimeConfig: SilgiRuntimeConfig$1 & {
+        [key: string]: any;
+    };
+    storages: string[];
+    hooks: NestedHooks<SilgiCLIHooks$1>;
+    plugins: {
+        path: string;
+        packageImport: string;
+    }[];
+    baseURL: string;
+    compatibilityDate: CompatibilityDates;
+    modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
+    _modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
+    isPreparingModules: boolean;
+    debug: true | {
+        command?: boolean;
+        install?: boolean;
+    };
+    preset: PresetName;
+    static: boolean;
+    logLevel: LogLevel;
+    appConfig: AppConfig;
+    appConfigFiles: string[];
+    codegen: {
+        env: {
+            safeList: string[][];
+        };
+    };
+    storage: StorageMounts$1;
+    devStorage: StorageMounts$1;
+    workspaceDir: string;
+    rootDir: string;
+    srcDir: string;
+    migrationDir: string;
+    scanDirs: string[];
+    build: {
+        dir: string;
+        typesDir: string;
+        /**
+         * It is recommended to use `addTemplate` from `@nuxt/kit` instead of this option.
+         *
+         *
+         * @example
+         * ```js
+         * templates: [
+         *   {
+         *     src: '~/modules/support/plugin.js', // `src` can be absolute or relative
+         *     dst: 'support.js', // `dst` is relative to project `.nuxt` dir
+         *   }
+         * ]
+         * ```
+         */
+        templates: SilgiTemplate$1<any>[];
+    };
+    modulesDir: string[];
+    output: {
+        dir: string;
+        serverDir: string;
+        publicDir: string;
+    };
+    serverDir: string;
+    clientDir: string;
+    silgi: {
+        /**
+         * @default "{serverDir}/silgi"
+         */
+        serverDir: string;
+        clientDir: string;
+        /**
+         * @default "{serverDir}/public"
+         */
+        publicDir: string;
+        /**
+         * @default "{silgi.serverDir}/utils"
+         */
+        utilsDir: string;
+        /**
+         * @default "{silgi.serverDir}/types"
+         */
+        typesDir: string;
+        /**
+         * @default "{silgi.serverDir}/vfs"
+         */
+        vfsDir: 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;
-}
-interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRuntimeOptions> {
-    options: DeepPartial<SilgiOptions>;
-}
-interface BuildSilgi {
-    framework?: {
-        nitro?: NitroApp;
+    imports: UnimportPluginOptions | false;
+    watchOptions: ChokidarOptions;
+    nodeModulesDirs: string[];
+    devServer: {
+        watch: string[];
     };
-    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>;
+    framework: SilgiFrameworkInfo$1;
     /**
-     * Matched router Node
+     * More customizable than `ignorePrefix`: all files matching glob patterns specified inside the `ignore` array will be ignored in building.
      *
-     * @experimental The object structure may change in non-major version.
-     */
-    matchedRoute?: SilgiRoute;
-    sessions?: Record<string, Session>;
-    clientAddress?: string;
-    source?: any;
-}
-/**
- * Bu nitrojs, h3 event or request context.
- */
-interface SilgiEvent extends Record<string, unknown> {
-    /**
-     * Event context.
+     * @default ["**\/*.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}",".nuxt/analyze",".nuxt","**\/-*.*"]
      */
-    readonly context: SilgiRuntimeContext;
+    ignore: Array<string>;
     /**
-     * Incoming HTTP request info.
+     * Whether Nuxt is running in development mode.
      *
-     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
-     */
-    readonly req: ServerRequest;
-    /**
-     * Access to the parsed request URL.
+     * Normally, you should not need to set this.
      *
-     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/URL)
+     * @default false
      */
-    readonly url: URL;
+    dev: boolean;
     /**
-     * Prepared HTTP response.
+     * jiti with stub mode
+     * @default false
      */
-    readonly res: {
-        status?: number;
-        statusText?: string;
-        readonly headers: Headers;
-    };
-}
-
-/**
- * The listeners to Silgi
- */
-interface SilgiRuntimeHooks {
+    stub: boolean;
     /**
-     * Called after Silgi initialization, when the Silgi instance is ready to work.
-     * @param silgi The configured Silgi object
-     * @returns Promise
+     * Whether your app is being unit tested.
+     *
+     * @default false
      */
-    'ready': (silgi: Silgi) => HookResult;
+    test: boolean;
+    extensions: string[];
+    future: {
+        /**
+         * This enables 'Bundler' module resolution mode for TypeScript, which is the recommended setting for frameworks like Nuxt and Vite.
+         *
+         * It improves type support when using modern libraries with `exports`.
+         * You can set it to false to use the legacy 'Node' mode, which is the default for TypeScript.
+         *
+         * @default true
+         *
+         * @see [TypeScript PR implementing `bundler` module resolution](https://github.com/microsoft/TypeScript/pull/51669)
+         */
+        typescriptBundlerResolution: boolean;
+    };
+    typescript: {
+        /**
+         * TypeScript comes with certain checks to give you more safety and analysis of your program. Once you’ve converted your codebase to TypeScript, you can start enabling these checks for greater safety. [Read More](https://www.typescriptlang.org/docs/handbook/migrating-from-javascript.html#getting-stricter-checks)
+         *
+         * @default true
+         */
+        strict: boolean;
+        /**
+         * Modules to generate deep aliases for within `compilerOptions.paths`. This does not yet support subpaths. It may be necessary when using Nuxt within a pnpm monorepo with `shamefully-hoist=false`.
+         *
+         * @default ["nitro/types","nitro/runtime","defu","h3","consola","ofetch","@unhead/vue","@nuxt/devtools","vue","@vue/runtime-core","@vue/compiler-sfc","vue-router","vue-router/auto-routes","unplugin-vue-router/client","@nuxt/schema","nuxt"]
+         */
+        hoist: Array<string>;
+        /**
+         * Include parent workspace in the Nuxt project. Mostly useful for themes and module authors.
+         *
+         * @default false
+         */
+        includeWorkspace: boolean;
+        /**
+         * Enable build-time type checking.
+         *
+         * If set to true, this will type check in development. You can restrict this to build-time type checking by setting it to `build`. Requires to install `typescript` and `vue-tsc` as dev dependencies.
+         *
+         * @default false
+         *
+         * @see [Nuxt TypeScript docs](https://nuxt.com/docs/guide/concepts/typescript)
+         */
+        typeCheck: boolean | 'build';
+        /**
+         * You can extend generated `.nuxt/tsconfig.json` using this option.
+         *
+         */
+        tsConfig: TSConfig;
+        /**
+         * Generate a `*.vue` shim.
+         *
+         * We recommend instead letting the [official Vue extension](https://marketplace.visualstudio.com/items?itemName=Vue.volar) generate accurate types for your components.
+         * Note that you may wish to set this to `true` if you are using other libraries, such as ESLint, that are unable to understand the type of `.vue` files.
+         *
+         * @default false
+         */
+        shim: boolean;
+        /**
+         * @default "types/silgi.tsconfig.json"
+         */
+        tsconfigPath: string;
+        /**
+         * @default true
+         */
+        generateTsConfig: boolean;
+        /**
+         * @default ['silgiTypes']
+         */
+        customConditions: string[];
+        /**
+         * Enable generating runtime configuration types.
+         *
+         * @default true
+         */
+        generateRuntimeConfigTypes: boolean;
+        /**
+         * @default false
+         * Behavior of import paths in auto-generated silgi files
+         */
+        removeFileExtension: boolean;
+    };
+    alias: Record<string, string>;
     /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
+     * @default ['silgi']
      */
-    'close': (silgi: Silgi) => HookResult;
-    'app:setup:start': (silgi: Silgi) => HookResult;
-    'request:on': (event: SilgiEvent) => HookResult;
-    'fetch:before': (context: ModuleHookContext) => HookResult;
-    'fetch:after': (context: ModuleHookContext) => HookResult;
-    'fetch:error': (context: Omit<ModuleHookContext, 'event'>) => HookResult;
-    'fetch:finally': (context: Omit<ModuleHookContext, 'event'>) => HookResult;
-    'error': CaptureError;
-}
-
-interface SilgiRuntimeConfig {
-}
-interface SilgiOptions {
-    consolaOptions?: Partial<ConsolaOptions>;
-    present: PresetNameInput;
-    hooks: Partial<SilgiRuntimeHooks & DefaultHooks>;
+    conditions: string[];
     /**
-     * Set to `true` to enable debug mode.
+     * Pass options directly to `node-ignore` (which is used by Nuxt to ignore files).
      *
-     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
      *
-     * @default false
+     * @see [node-ignore](https://github.com/kaelzhang/node-ignore)
+     *
+     * @example
+     * ```js
+     * ignoreOptions: {
+     *   ignorecase: false
+     * }
+     * ```
      */
-    debug: boolean;
-    storage: StorageMounts;
-    putStorage?: Storage<StorageValue>;
-    runtimeConfig: SilgiRuntimeConfig & {
-        [key: string]: any;
-    };
-    captureError: CaptureError;
+    ignoreOptions: Options;
+    installPackages: Record<'dependencies' | 'devDependencies', Record<string, string>>;
+    apiFul: ApifulConfig;
     adapters: Record<string, Adapter<Record<string, any>, TablesSchema, InferModelTypes<TablesSchema>>>;
+}
+/**
+ * Silgi input config (silgi.config)
+ */
+interface SilgiCLIConfig extends DeepPartial<Omit<SilgiCLIOptions, 'preset' | 'compatibilityDate' | '_config' | '_c12' | 'consola'>>, C12InputConfig<SilgiCLIConfig>, Partial<SilgiModuleOptions> {
+    preset?: PresetNameInput;
+    extends?: string | string[] | SilgiPreset;
+    compatibilityDate?: CompatibilityDateSpec;
+}
+interface AppConfig {
     [key: string]: any;
 }
+interface LoadConfigOptions {
+    watch?: boolean;
+    c12?: WatchConfigOptions;
+    compatibilityDate?: CompatibilityDateSpec;
+    consola?: ConsolaInstance;
+}
 
 interface DotenvOptions {
     /**