silgi 0.3.13 → 0.4.1

package/dist/shared/{silgi.ClpvycKI.d.ts → silgi.CzUPBllI.d.mts}

@@ -1,22 +1,38 @@
-import { ConsolaOptions, ConsolaInstance } from 'consola';
-import { Hookable } from 'hookable';
-import { Ignore } from 'ignore';
-import { BuiltinDriverName, TransactionOptions, StorageValue, Storage } from 'unstorage';
-import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Defu } from 'defu';
-import { Router, H3Event } from 'h3';
+import { TypeSource, IResolvers } from '@graphql-tools/utils';
 import { TSConfig } from 'pkg-types';
-import { NitroApp } from 'nitropack/types';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { ConsolaOptions, ConsolaInstance, LogLevel } from 'consola';
+import { Hookable } from 'hookable';
+import { PresetOptions, PresetName, PresetNameInput } from 'silgi/presets';
+import { StorageMounts as StorageMounts$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1, ResolvedServiceType as ResolvedServiceType$1, SilgiDefaultShared as SilgiDefaultShared$1, SilgiModules as SilgiModules$1, ModuleMeta as ModuleMeta$1 } from 'silgi/types';
+import { Unimport } from 'unimport';
+import { BuiltinDriverName, TransactionOptions, Storage } from 'unstorage';
+import { ResolvedConfig, ConfigWatcher, C12InputConfig, WatchConfigOptions } from 'c12';
+import { ChokidarOptions } from 'chokidar';
+import { DateString, CompatibilityDates, CompatibilityDateSpec } from 'compatx';
+import { UnimportPluginOptions } from 'unimport/unplugin';
+import { ProviderName } from 'std-env';
+import { s as silgi, u as useStorage } from './silgi.40ZJYm8F.mjs';
+import { Ignore } from 'ignore';
 
-interface SilgiEvent extends Record<string, unknown> {
-}
+type HookResult = Promise<void> | void;
 
-interface SilgiMethods {
+interface SilgiCompatibilityIssue {
+    name: string;
+    message: string;
 }
-interface SilgiNamespaces {
+interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
+    /**
+     * Return formatted error message.
+     */
+    toString: () => string;
 }
-type BaseSilgiMethodType = 'post' | 'delete' | 'put' | 'get' | keyof SilgiMethods;
-interface DefaultNamespaces extends SilgiNamespaces {
+
+/**
+ * Bu nitrojs, h3 event or request context.
+ */
+interface SilgiEvent extends Record<string, unknown> {
 }
 
 interface SilgiSchema {
@@ -27,7 +43,7 @@ type BaseSchemaType<T extends StandardSchemaV1> = {
     [Action in BaseSilgiMethodType]?: Record<string, {
         input?: T;
         output?: T;
-        routerParams?: T;
+        router?: T;
     }>;
 };
 
@@ -70,85 +86,6 @@ type ExtractInputFromURI<TURI extends keyof SilgiURIs> = GetInput<ExtractPath<TU
 type ExtractOutputFromURI<TURI extends keyof SilgiURIs> = GetOutput<ExtractPath<TURI>>;
 type ExtractRouterParamsFromURI<TURI extends keyof SilgiURIs> = GetRouterParams<ExtractPath<TURI>>;
 
-interface SilgiRouterTypes {
-}
-interface SilgiHook {
-}
-interface DefaultHooks {
-}
-interface DefaultMethods {
-    get: string;
-    post: string;
-    put: string;
-    delete: string;
-    [key: string]: string;
-}
-interface DefaultMethods {
-    get: string;
-    post: string;
-    put: string;
-    delete: string;
-}
-type DeepPartial<T> = T extends void ? T : T extends Record<string, any> ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-type Awaitable<T> = T | Promise<T>;
-interface CreateScope {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<MethodResponse<ExtractOutputFromURI<TURI>>>;
-}
-
-interface SilgiCompatibilityIssue {
-    name: string;
-    message: string;
-}
-interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
-    /**
-     * Return formatted error message.
-     */
-    toString: () => string;
-}
-
-declare class SilgiHelper {
-    setEvent(key: string, value: any): void;
-    getEvent(key: string): any;
-    addH3App(router: Router): Promise<void>;
-    addNitroApp(nitro: NitroApp): Promise<void>;
-    /**
-     * [...router.ts] tum router tarayan ve ona gore isteklere yonlendiren alan.
-     */
-    handler(_request: Request | H3Event | Record<string, any>): Promise<void>;
-}
-
-interface SRNPartition {
-}
-interface SRNService {
-}
-interface SRNRegion {
-}
-interface SRNAccountId {
-}
-interface SRNResource {
-}
-interface SRN {
-    partition: string | undefined | SRNPartition;
-    service: string | undefined | SRNService;
-    region: string | undefined | SRNRegion;
-    accountId: string | undefined | SRNAccountId;
-    resource: string | undefined | SRNResource;
-}
-
-declare class SRNManager {
-    private readonly silgi;
-    constructor(silgi?: Silgi);
-    register(_srn: string): void;
-    handle(srn: string): SRN;
-    findService({ namespace, name }: {
-        namespace: string;
-        name: string;
-    }): any;
-    getAllServices(): any;
-}
-
 /**
  * @example
  * namespace: 'coreApi'
@@ -180,13 +117,23 @@ interface SilgiOperation {
     /**
      * 'coreApi/basket/post/createBasket'
      */
-    raw: keyof SilgiURIs;
+    raw: string;
     /**
      * '/book/basket/getAllBaskets'
      */
-    uri: string;
+    uri: keyof SilgiURIs;
+    /**
+     * ['coreApi', 'book', 'basket', 'getAllBaskets']
+     */
     parts: string[];
-    routerParams?: Record<string, string>;
+    /**
+     * {id: '123', name: 'John', bookId: '456', authorId: '789'}
+     */
+    routerParams?: Record<string, string | undefined>;
+    /**
+     * url ?limit=10&page=1
+     * {limit: '10', page: '1'}
+     */
     query?: Record<string, string>;
 }
 
@@ -208,110 +155,300 @@ interface StorageConfig<TInput> {
     key?: StorageKeyGenerator<TInput>;
     scope?: 'request' | 'global';
 }
-
-interface SilgiEventContext {
-    _context: any;
-    silgi: Silgi;
-    namespace?: string;
-    serviceName?: string;
-    methodName?: string;
+interface StorageKeyParams<TInput = unknown> {
+    operation: SilgiOperation;
+    input: TInput;
+    requestId?: string;
+    keyGenerator?: StorageKeyGenerator<TInput>;
+    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
 }
+
 interface SilgiOptions {
-    /**
-     * @default 'nitrojs'
-     */
-    environment?: ('nitrojs' | 'h3' | 'undefined');
-    isPackage: boolean;
-    /**
-     *
-     * @private
-     */
-    _eventContext?: Map<string, SilgiEventContext>;
-    /**
-     *
-     * @private
-     */
-    _requiredModules: any;
-    srn: SRNManager;
     consolaOptions?: Partial<ConsolaOptions>;
-    h3Router?: Router;
-    nitro?: NitroApp;
-    /**
-     * Define the root directory of your application.
-     *
-     * This property can be overwritten (for example, running `nuxt ./my-app/` will set the `rootDir` to the absolute path of `./my-app/` from the current/working directory.
-     * It is normally not needed to configure this option.
-     *
-     * @default "/<rootDir>"
-     */
-    rootDir: string;
-    /**
-     *
-     * default "/<rootDir>/.silgi"
-     */
-    buildDir: string;
     builder: 'nuxt' | 'nitrojs';
     /**
-     * @default ['.js', '.mjs', '.ts']
-     */
-    extensions?: string[];
-    /**
+     * Set to `true` to enable debug mode.
      *
-     * @private
+     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
+     *
+     * @default false
      */
-    _silgiConfigFile: any;
+    debug: boolean;
+    storage: StorageMounts;
+    [key: string]: any;
+}
+
+interface SilgiAppPlugin {
+    (silgi: Silgi): Promise<void> | void;
+}
+
+interface CapturedErrorContext {
+    event?: SilgiEvent;
+    [key: string]: unknown;
+}
+type CaptureError = (error: Error, context: CapturedErrorContext) => void;
+
+/**
+ * The listeners to Silgi
+ */
+interface SilgiHooks {
     /**
-     *
-     * @private
+     * Called after Silgi initialization, when the Silgi instance is ready to work.
+     * @param silgi The configured Silgi object
+     * @returns Promise
      */
-    _silgiConfigFiles: Array<any>;
+    'ready': (silgi: Silgi) => HookResult;
     /**
-     * Modules are Nuxt extensions which can extend its core functionality and add endless integrations.
-     *
-     * Each module is either a string (which can refer to a package, or be a path to a file), a tuple with the module as first string and the options as a second object, or an inline module function.
-     * Nuxt tries to resolve each item in the modules array using node require path (in `node_modules`) and then will be resolved from project `srcDir` if `~` alias is used.
-     *
-     *
-     * @note Modules are executed sequentially so the order is important. First, the modules defined in `nuxt.config.ts` are loaded. Then, modules found in the `modules/`
-     * directory are executed, and they load in alphabetical order.
-     *
-     * @example
-     * ```js
-     * modules: [
-     *   // Using package name
-     *   '@nuxtjs/axios',
-     *   // Relative to your project srcDir
-     *   '~/modules/awesome.js',
-     *   // Providing options
-     *   ['@nuxtjs/google-analytics', { ua: 'X1234567' }],
-     *   // Inline definition
-     *   function () {}
-     * ]
-     * ```
+     * 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;
+    'method:before': (context: ModuleHookContext) => HookResult;
+    'method:after': (context: ModuleHookContext) => HookResult;
+    'method:error': (context: ModuleHookContext) => HookResult;
+    'method:finally': (context: ModuleHookContext) => HookResult;
+    'event:before': (event: SilgiEvent) => HookResult;
+    'error': CaptureError;
+}
+
+type SilgiServiceInterface<T extends BaseSchemaType<StandardSchemaV1>> = {
+    [Action in keyof T]: T[Action] extends Record<string, any> ? {
+        [Method in keyof T[Action]]: {
+            input: T[Action][Method]['input'];
+            output: T[Action][Method]['output'];
+            router: T[Action][Method]['router'];
+        };
+    } : never;
+};
+type ServiceType<T> = Partial<{
+    [Namespace in keyof T]: T[Namespace] extends Record<string, any> ? {
+        [Service in keyof T[Namespace]]?: MethodHandlerType<T[Namespace][Service]>;
+    } : never;
+}>;
+type RequiredServiceType<T> = {
+    [K in keyof T]-?: T[K] extends Record<string, any> ? {
+        [P in keyof T[K]]-?: MethodHandlerType<T[K][P]>;
+    } : never;
+};
+/**
+ * const test: ResolvedServiceType = {
+  aaa: {
+    bbb: {
+      delete: {
+        storage: {
+          handler: () => {}
+        },
+      },
+    },
+  },
+}
+ */
+type ResolvedServiceType = {
+    [K in string]: {
+        [P in string]: {
+            [Q in BaseSilgiMethodType]?: {
+                [M in string]: ResolvedMethodHandlerType;
+            };
+        };
+    };
+};
+
+interface FrameworkContext {
+}
+interface Silgi {
+    schemas: any;
+    services: ResolvedServiceType;
+    shared: SilgiDefaultShared;
+    uris: Record<string, any>;
+    modulesURIs: Partial<Record<keyof SilgiModules, any>>;
+    scannedHandlers: Map<string, ResolvedMethodHandlerType>;
+    plugins: SilgiAppPlugin[];
+    framework: FrameworkContext;
+    _ignore?: Ignore;
+    hooks: Hookable<SilgiHooks & DefaultHooks>;
+    hook: Silgi['hooks']['hook'];
+    callHook: Silgi['hooks']['callHook'];
+    addHooks: Silgi['hooks']['addHooks'];
+    ready: () => Promise<void>;
+    close: () => Promise<void>;
+    logger: ConsolaInstance;
+    storage: Storage;
+    options: SilgiOptions & SilgiModuleOptions;
+    captureError: CaptureError;
+}
+interface SilgiConfig extends Pick<Silgi, 'services' | 'shared' | 'uris' | 'schemas' | 'modulesURIs' | 'plugins' | 'framework'>, Partial<SilgiModuleOptions> {
+    options: DeepPartial<SilgiOptions>;
+}
+type SilgiFunction = typeof silgi;
+
+interface SilgiDefaultShared extends SilgiModuleShared {
+    storage: (...data: Parameters<typeof useStorage>) => ReturnType<typeof useStorage>;
+    silgi: SilgiFunction;
+}
+interface SilgiModuleShared {
+}
+interface ExtendShared {
+}
+
+interface MethodSchemaType<Input, Output> {
+    default: {
+        input?: Input;
+        output: Output;
+    };
+    handler: (input: Input, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<Output>;
+    modules?: Partial<ModuleConfigurations>;
+    storage?: StorageConfig<Input>;
+}
+type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
+type MethodHandlerType<T> = {
+    [Action in keyof T]: T[Action] extends Record<string, any> ? {
+        [Method in keyof T[Action]]: {
+            default?: {
+                input?: StandardSchemaV1.InferInput<T[Action][Method]['input']>;
+                output?: StandardSchemaV1.InferInput<T[Action][Method]['output']>;
+            };
+            handler: (router: StandardSchemaV1.InferInput<T[Action][Method]['router']>, input: StandardSchemaV1.InferInput<T[Action][Method]['input']>, shared: SilgiDefaultShared, event: SilgiEvent) => EventHandlerResponse<StandardSchemaV1.InferOutput<T[Action][Method]['output']>>;
+            modules?: Partial<ModuleConfigurations>;
+            storage?: StorageConfig<T[Action][Method]['input']>;
+        };
+    } : never;
+};
+interface ResolvedMethodHandlerType {
+    input?: Partial<BaseSchemaType<any>>;
+    output: Partial<BaseSchemaType<any>>;
+    handler: (router: StandardSchemaV1.InferInput<any>, input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
+    modules?: Partial<ModuleConfigurations>;
+    storage?: StorageConfig<StandardSchemaV1.InferInput<any>>;
+    execute: (input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
+}
+type MethodResponse<T> = {
+    success: true;
+    data: T;
+    cached?: boolean;
+} | {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+};
+
+interface SilgiMethods {
+}
+interface SilgiNamespaces {
+}
+interface DefaultNamespaces extends SilgiNamespaces {
+}
+interface SilgiRouterTypes {
+}
+interface SilgiHook {
+}
+type BaseSilgiMethodType = 'post' | 'delete' | 'put' | 'get' | keyof SilgiMethods;
+interface DefaultHooks {
+}
+type DeepPartial<T> = T extends void ? T : T extends Record<string, any> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type Awaitable<T> = T | Promise<T>;
+interface CreateScope {
+    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<MethodResponse<ExtractOutputFromURI<TURI>>>;
+}
+
+type SilgiPreset = SilgiCLIConfig | (() => SilgiCLIConfig);
+interface SilgiPresetMeta {
+    url: string;
+    name: string;
+    stdName?: ProviderName;
+    aliases?: string[];
+    static?: boolean;
+    compatibilityDate?: DateString;
+}
+
+/**
+ * SilgiCLI normalized options (silgi.options)
+ */
+interface SilgiCLIOptions extends PresetOptions {
+    _config: SilgiCLIConfig;
+    _c12: ResolvedConfig<SilgiCLIConfig> | ConfigWatcher<SilgiCLIConfig>;
+    _cli?: {
+        command?: string;
+    };
+    namespaces: string[];
+    plugins: {
+        path: string;
+        packageImport: string;
+    }[];
+    routeRules: Record<string, string>;
+    compatibilityDate: CompatibilityDates;
     modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
-    modulesDir: Array<string>;
+    _modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
+    debug: boolean;
+    preset: PresetName;
+    static: boolean;
+    logLevel: LogLevel;
+    appConfig: AppConfig;
+    appConfigFiles: string[];
+    storage: StorageMounts$1;
+    devStorage: StorageMounts$1;
+    workspaceDir: string;
+    rootDir: string;
+    srcDir: string;
+    scanDirs: string[];
+    apiDir: string;
+    routesDir: string;
+    build: {
+        dir: string;
+        typesDir: string;
+    };
+    modulesDir: string[];
+    output: {
+        dir: string;
+        serverDir: string;
+        publicDir: string;
+    };
+    serverDir: string;
+    clientDir: string;
+    silgi: {
+        serverDir: string;
+        clientDir: string;
+        publicDir: string;
+        utilsDir: string;
+        composablesDir: string;
+        typesDir: string;
+        servicesDir: string;
+    };
+    imports: UnimportPluginOptions | false;
+    watchOptions: ChokidarOptions;
+    nodeModulesDirs: string[];
+    commands: {
+        preview: string;
+        deploy: string;
+    };
+    framework: SilgiFrameworkInfo$1;
     /**
+     * More customizable than `ignorePrefix`: all files matching glob patterns specified inside the `ignore` array will be ignored in building.
      *
-     * @private
+     * @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","**\/-*.*"]
      */
-    _installedModules: Array<{
-        meta: ModuleMeta;
-        timings?: Record<string, number | undefined>;
-        entryPath?: string;
-        packageName: string;
-        active?: boolean;
-    }>;
-    silgiDir: string;
+    ignore: Array<string>;
     /**
+     * Whether Nuxt is running in development mode.
      *
-     * @private
+     * Normally, you should not need to set this.
+     *
+     * @default false
      */
-    _modules: Array<any>;
+    dev: boolean;
     /**
-     * `future` is for early opting-in to new features that will become default in a future (possibly major) version of the framework.
+     * 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.
@@ -325,10 +462,6 @@ interface SilgiOptions {
          */
         typescriptBundlerResolution: boolean;
     };
-    /**
-     * Configuration for Nuxt's TypeScript integration.
-     *
-     */
     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)
@@ -372,120 +505,140 @@ interface SilgiOptions {
          * @default false
          */
         shim: boolean;
-    };
-    /**
-     * Whether Nuxt is running in development mode.
-     *
-     * Normally, you should not need to set this.
-     *
-     * @default false
-     */
-    dev: boolean;
-    /**
-     * Whether your app is being unit tested.
-     *
-     * @default false
-     */
-    test: boolean;
-    /**
-     * 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;
-    namespaces: string[];
-    /**
-     * Define the server directory of your Nuxt application, where Nitro routes, middleware and plugins are kept.
-     *
-     * If a relative path is specified, it will be relative to your `rootDir`.
-     *
-     * @default "/<rootDir>/server"
-     */
-    serverDir: string;
-    /**
-     * Define the server directory of your Nuxt application, where Nitro routes, middleware and plugins are kept.
-     *
-     * If a relative path is specified, it will be relative to your `rootDir`.
-     *
-     * @default "/<rootDir>/app"
-     */
-    clientDir: string;
-    /**
-     * Customize default directory structure used by Nuxt.
-     *
-     * It is better to stick with defaults unless needed.
-     *
-     */
-    dir: {
-        /** @default "/<srcDir>" */
-        client: string;
         /**
-         * The modules directory, each file in which will be auto-registered as a Nuxt module.
-         *
-         * @default "/<serverDir>/silgi/modules"
+         * @default "types/silgi.tsconfig.json"
          */
-        modules: string;
+        tsconfigPath: string;
         /**
-         * The shared directory. This directory is shared between the app and the server.
-         *
-         * @default "/<rootDir>/shared"
+         * @default true
          */
-        shared: string;
+        generateTsConfig: boolean;
         /**
-         * The directory containing your static files, which will be directly accessible via the Nuxt server and copied across into your `dist` folder when your app is generated.
-         *
-         * @default "/<rootDir>/public"
+         * @default false
+         */
+        internalPaths?: boolean;
+        /**
+         * @default ['silgiTypes']
          */
-        public: string;
+        customConditions: string[];
     };
+    alias: Record<string, string>;
     /**
-     * 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","**\/-*.*"]
+     * @default ['silgi']
      */
-    ignore: Array<string>;
-    helper: SilgiHelper;
-    storage: StorageMounts;
+    conditions: string[];
+}
+/**
+ * Silgi input config (silgi.config)
+ */
+interface SilgiCLIConfig extends DeepPartial<Omit<SilgiCLIOptions, 'preset' | 'compatibilityDate'>>, C12InputConfig<SilgiCLIConfig>, DeepPartial<SilgiModuleOptions> {
+    preset?: PresetNameInput;
+    extends?: string | string[] | SilgiPreset;
+    compatibilityDate?: CompatibilityDateSpec;
+}
+interface AppConfig {
     [key: string]: any;
 }
+interface LoadConfigOptions {
+    watch?: boolean;
+    c12?: WatchConfigOptions;
+    compatibilityDate?: CompatibilityDateSpec;
+}
+
+interface ImportItem {
+    importItems: {
+        [key: string]: {
+            import: {
+                type?: boolean;
+                name: string;
+            }[];
+            from: string;
+        };
+    };
+    customImports: string[];
+    customContent?: string[];
+    functions?: string[];
+}
+interface SilgiCLI {
+    services: ResolvedServiceType$1;
+    shareds: SilgiDefaultShared$1;
+    uris: Record<string, any>;
+    schemas: Record<string, any>;
+    modulesURIs: Partial<Record<keyof SilgiModules$1, any>>;
+    scannedURIs: Map<string, string>;
+    hooks: Hookable<SilgiCLIHooks>;
+    hook: SilgiCLI['hooks']['hook'];
+    callHook: SilgiCLI['hooks']['callHook'];
+    addHooks: SilgiCLI['hooks']['addHooks'];
+    storage: Storage;
+    unimport?: Unimport;
+    logger: ConsolaInstance;
+    close: () => Promise<void>;
+    updateConfig: (config: SilgiCLIDynamicConfig) => void | Promise<void>;
+    scanModules: Array<{
+        meta: ModuleMeta$1;
+        timings?: Record<string, number | undefined>;
+        entryPath: string;
+        installed?: boolean;
+    }>;
+    options: SilgiCLIOptions;
+    _requiredModules: Record<string, boolean>;
+}
+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>;
+}
 
-type HookResult = Promise<void> | void;
 type TSReference = {
     types: string;
 } | {
     path: string;
 };
-/**
- * The listeners to Silgi
- */
-interface SilgiHooks {
+interface SilgiCLIHooks {
     /**
      * Called after Silgi initialization, when the Silgi instance is ready to work.
      * @param silgi The configured Silgi object
      * @returns Promise
      */
-    'ready': (silgi: Silgi) => HookResult;
+    'ready': (silgi: SilgiCLI) => 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;
-    'method:before': (context: ModuleHookContext) => HookResult;
-    'method:after': (context: ModuleHookContext) => HookResult;
-    'method:error': (context: ModuleHookContext) => HookResult;
-    'method:finally': (context: ModuleHookContext) => HookResult;
+    'close': (silgi: SilgiCLI) => HookResult;
     'module:register:before': (module: SilgiModule) => HookResult;
-    'module:register:after': (module: SilgiOptions['_installedModules'][number]) => HookResult;
+    'module:register:after': (module: SilgiCLI['scanModules'][number]) => HookResult;
     'module:setup:finish': (module: SilgiModule) => HookResult;
     'module:before:excute': (context: ModuleHookContext) => HookResult;
     'module:after:excute': (context: ModuleHookContext) => HookResult;
     'module:error': (context: ModuleHookContext) => HookResult;
-    'event:before': (event: SilgiEvent) => HookResult;
-    'h3:app:setup': (router: Router) => HookResult;
+    'prepare:createCoreFramework': (options: ImportItem) => HookResult;
+    'prepare:createDTSFramework': (options: ImportItem) => HookResult;
     /**
      * Allows extending compatibility checks.
      * @param compatibility Compatibility object
@@ -503,39 +656,15 @@ interface SilgiHooks {
         declarations: string[];
         tsConfig: TSConfig;
     }) => HookResult;
-    /**
-     * 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
-     */
     'prepare:core.ts': (options: {
-        importedItems: {
-            [key: string]: {
-                import: {
-                    type?: boolean;
-                    name: string;
-                }[];
-                from: string;
-            };
-        };
-        imports: string[];
         uris: string[];
         services: string[];
         shareds: string[];
         schemas: string[];
-        modules: string[];
-    }) => HookResult;
+        buildSilgiExtraContent: string[];
+    } & ImportItem) => HookResult;
+    'after:prepare:core.ts': (content: string[]) => HookResult;
     'prepare:schema.ts': (options: {
-        importedItems: {
-            [key: string]: {
-                import: {
-                    type?: boolean;
-                    name: string;
-                }[];
-                from: string;
-            };
-        };
-        imports: string[];
         configs: {
             key: string;
             value: string;
@@ -559,19 +688,9 @@ interface SilgiHooks {
             isSilgiContext?: boolean;
         }[];
         storeBase: string[];
-    }) => HookResult;
-    'prepare:h3.d.ts': (options: {
-        importedItems: {
-            [key: string]: {
-                import: {
-                    type?: boolean;
-                    name: string;
-                }[];
-                from: string;
-            };
-        };
-        imports: string[];
-    }) => HookResult;
+    } & ImportItem) => HookResult;
+    'after:prepare:schema.ts': (content: string[]) => HookResult;
+    'prepare:framework.d.ts': (options: {} & ImportItem) => HookResult;
     'read:core.ts': (data: () => Awaitable<{
         context: string;
         object: {
@@ -579,9 +698,14 @@ interface SilgiHooks {
             services?: string[];
             shareds?: string[];
             schemas?: string[];
+            modulesURIs?: string[];
         };
         path: string;
     }>) => HookResult;
+    'before:graphql:schema': (data: {
+        typeDefs: TypeSource[];
+        resolvers: Array<IResolvers<any, any>>;
+    }) => HookResult;
 }
 
 interface SilgiModules {
@@ -590,6 +714,7 @@ interface SilgiModuleMethods {
 }
 interface SilgiModuleOptions {
 }
+type SilgiModuleInput = (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false);
 interface SilgiCompatibility {
     /**
      * Required silgi version in semver format.
@@ -615,6 +740,7 @@ interface ModuleMeta {
             method?: true;
             schema?: true;
             event?: true;
+            options?: true;
         };
         variable?: {
             shared?: true;
@@ -631,9 +757,23 @@ interface ModuleMeta {
      * Constraints for the versions of silgi or features this module requires.
      */
     compatibility?: SilgiCompatibility;
+    /**
+     * @private
+     */
+    _modules?: {
+        [key: string]: string;
+    };
+    /**
+     * @private
+     */
+    _packageName?: string;
     readonly dependencies?: ReadonlyArray<string>;
     [key: string]: unknown;
 }
+interface ResolvedModuleMeta extends ModuleMeta {
+    configKey: string;
+    name: string;
+}
 type ModuleHookContext = Readonly<{
     event?: SilgiEvent;
     operation?: SilgiOperation;
@@ -658,10 +798,9 @@ type ResolvedModuleOptions<TOptions extends ModuleOptions, TOptionsDefaults exte
 ]>>;
 interface ModuleDefinition<TOptions extends ModuleOptions, TOptionsDefaults extends Partial<TOptions>, TWith extends boolean> {
     meta?: ModuleMeta;
-    defaults?: TOptionsDefaults | ((silgi: Silgi) => Awaitable<TOptionsDefaults>);
-    hooks?: Partial<SilgiHooks>;
-    cli?: (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: Silgi) => ModuleSetupReturn;
-    setup?: (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: Silgi) => ModuleSetupReturn;
+    defaults?: TOptionsDefaults | ((silgi: SilgiCLI) => Awaitable<TOptionsDefaults>);
+    hooks?: Partial<SilgiCLIHooks>;
+    setup?: (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: SilgiCLI) => ModuleSetupReturn;
 }
 interface ModuleSetupInstallResult {
     /**
@@ -675,135 +814,10 @@ interface ModuleSetupInstallResult {
 }
 type ModuleSetupReturn = Awaitable<false | void | ModuleSetupInstallResult>;
 interface SilgiModule<TOptions extends ModuleOptions = ModuleOptions, TOptionsDefaults extends Partial<TOptions> = Partial<TOptions>, TWith extends boolean = false> {
-    (this: void, resolvedOptions: TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions, silgi: Silgi, cli?: boolean): ModuleSetupReturn;
-    getOptions?: (inlineOptions?: Partial<TOptions>, silgi?: Silgi) => Promise<TWith extends true ? ResolvedModuleOptions<TOptions, TOptionsDefaults> : TOptions>;
+    (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>;
-    cli?: (silgi: Silgi) => ModuleSetupReturn;
-}
-type ModuleConfiguration<K extends keyof SilgiModuleMethods = keyof SilgiModuleMethods> = SilgiModuleMethods[K];
-type ModuleConfigurations = {
-    [K in keyof SilgiModuleMethods]?: ModuleConfiguration;
-};
-
-declare function useStorage<T extends StorageValue = StorageValue>(base?: StorageConfig<T>['base']): Storage<T>;
-
-interface SilgiDefaultShared extends SilgiModuleShared {
-    storage: (...data: Parameters<typeof useStorage>) => ReturnType<typeof useStorage>;
-    silgi: SilgiFunction;
-}
-interface SilgiModuleShared {
-}
-interface ExtendShared {
-}
-
-type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
-type MethodHandlerType<T> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            default?: {
-                input?: StandardSchemaV1.InferInput<T[Action][Method]['input']>;
-                output?: StandardSchemaV1.InferInput<T[Action][Method]['output']>;
-            };
-            handler: (router: StandardSchemaV1.InferInput<T[Action][Method]['router']>, input: StandardSchemaV1.InferInput<T[Action][Method]['input']>, shared: SilgiDefaultShared, event: SilgiEvent) => EventHandlerResponse<StandardSchemaV1.InferOutput<T[Action][Method]['output']>>;
-            modules?: ModuleConfigurations;
-            storage?: StorageConfig<T[Action][Method]['input']>;
-        };
-    } : never;
-};
-interface ResolvedMethodHandlerType {
-    input?: Partial<BaseSchemaType<any>>;
-    output: Partial<BaseSchemaType<any>>;
-    handler: (router: StandardSchemaV1.InferInput<any>, input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
-    modules?: ModuleConfigurations;
-    storage?: StorageConfig<StandardSchemaV1.InferInput<any>>;
-    execute: (input: StandardSchemaV1.InferInput<any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<StandardSchemaV1.InferInput<any>>;
-}
-type MethodResponse<T> = {
-    success: true;
-    data: T;
-    cached?: boolean;
-} | {
-    success: false;
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-};
-
-declare function silgi(event?: SilgiEvent | Record<string, any>): {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<MethodResponse<ExtractOutputFromURI<TURI>>>;
-};
-
-type SilgiServiceInterface<T extends BaseSchemaType<StandardSchemaV1>> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            input: T[Action][Method]['input'];
-            output: T[Action][Method]['output'];
-            router: T[Action][Method]['router'];
-        };
-    } : never;
-};
-type ServiceType<T> = Partial<{
-    [Namespace in keyof T]: T[Namespace] extends Record<string, any> ? {
-        [Service in keyof T[Namespace]]?: MethodHandlerType<T[Namespace][Service]>;
-    } : never;
-}>;
-type RequiredServiceType<T> = {
-    [K in keyof T]-?: T[K] extends Record<string, any> ? {
-        [P in keyof T[K]]-?: MethodHandlerType<T[K][P]>;
-    } : never;
-};
-/**
- * const test: ResolvedServiceType = {
-  aaa: {
-    bbb: {
-      delete: {
-        storage: {
-          handler: () => {}
-        },
-      },
-    },
-  },
-}
- */
-type ResolvedServiceType = {
-    [K in string]: {
-        [P in string]: {
-            [Q in BaseSilgiMethodType]?: {
-                [M in string]: ResolvedMethodHandlerType;
-            };
-        };
-    };
-};
-
-interface Silgi {
-    schemas: any;
-    services: ResolvedServiceType;
-    shared: SilgiDefaultShared;
-    uris: Record<string, any>;
-    scannedHandlers: Map<string, ResolvedMethodHandlerType>;
-    /**
-     *
-     * @private
-     */
-    _initializedModules: Record<string, SilgiModule>;
-    _ignore?: Ignore;
-    _version: string;
-    hooks: Hookable<SilgiHooks & DefaultHooks>;
-    hooksNames: string[];
-    hook: Silgi['hooks']['hook'];
-    callHook: Silgi['hooks']['callHook'];
-    addHooks: Silgi['hooks']['addHooks'];
-    ready: () => Promise<void>;
-    close: () => Promise<void>;
-    logger: ConsolaInstance;
-    storage: Storage;
-    options: SilgiOptions;
-}
-interface SilgiConfig extends Pick<Silgi, 'services' | 'shared' | 'uris' | 'schemas' | '_initializedModules'> {
-    options: DeepPartial<SilgiOptions>;
 }
-type SilgiFunction = typeof silgi;
+type ModuleConfigurations = SilgiModuleMethods;
 
-export { type DefaultMethods as A, type BaseSchemaType as B, type DefaultHooks as C, type DeepPartial as D, type ExtendShared as E, type Awaitable as F, type CreateScope as G, type ModuleOptions as M, type RequiredServiceType as R, type SilgiOptions as S, type URIsTypes as U, type SilgiModuleOptions as a, type SilgiConfig as b, SilgiHelper as c, type SilgiRouterTypes as d, type ModuleDefinition as e, type SilgiModule as f, type SilgiServiceInterface as g, type DefaultNamespaces as h, type Silgi as i, type SilgiOperation as j, type MergedSilgiSchema as k, type ServiceType as l, type SilgiSchema as m, type SilgiModuleShared as n, type SilgiEvent as o, type SilgiModuleMethods as p, type SilgiModules as q, type SilgiNamespaces as r, type SilgiDefaultShared as s, type SilgiURIs as t, type ExtractInputFromURI as u, type ExtractOutputFromURI as v, type ExtractRouterParamsFromURI as w, type SilgiStorageBase as x, silgi as y, type SilgiHook as z };
+export type { ResolvedServiceType as $, AppConfig as A, BaseSchemaType as B, CreateScope as C, DefaultNamespaces as D, ModuleSetupReturn as E, SilgiModule as F, ModuleConfigurations as G, SilgiOperation as H, SilgiPreset as I, SilgiPresetMeta as J, MethodSchemaType as K, LoadConfigOptions as L, ModuleMeta as M, EventHandlerResponse as N, MethodHandlerType as O, ResolvedMethodHandlerType as P, MethodResponse as Q, ResolvedModuleMeta as R, SilgiServiceInterface as S, TSReference as T, SilgiAppPlugin as U, CapturedErrorContext as V, CaptureError as W, SilgiSchema as X, MergedSilgiSchema as Y, ServiceType as Z, RequiredServiceType as _, SilgiCLIOptions as a, SilgiDefaultShared as a0, SilgiModuleShared as a1, ExtendShared as a2, FrameworkContext as a3, Silgi as a4, SilgiConfig as a5, SilgiFunction as a6, ImportItem as a7, SilgiCLI as a8, SilgiCLIDynamicConfig as a9, SilgiFrameworkInfo as aa, NitroBuildInfo as ab, SilgiURIs as ac, URIsTypes as ad, ExtractInputFromURI as ae, ExtractOutputFromURI as af, ExtractRouterParamsFromURI as ag, StorageMounts as ah, SilgiStorageBase as ai, StorageKeyGenerator as aj, StorageConfig as ak, StorageKeyParams as al, SilgiCLIConfig as b, SilgiCLIHooks as c, SilgiCompatibilityIssue as d, SilgiCompatibilityIssues as e, SilgiOptions as f, SilgiEvent as g, SilgiMethods as h, SilgiNamespaces as i, SilgiRouterTypes as j, SilgiHook as k, BaseSilgiMethodType as l, DefaultHooks as m, DeepPartial as n, Awaitable as o, SilgiHooks as p, SilgiModules as q, SilgiModuleMethods as r, SilgiModuleOptions as s, SilgiModuleInput as t, SilgiCompatibility as u, ModuleHookContext as v, ModuleOptions as w, ResolvedModuleOptions as x, ModuleDefinition as y, ModuleSetupInstallResult as z };