silgi 0.24.0 → 0.24.2

package/dist/types/index.d.ts

@@ -1,1138 +0,0 @@
-import { C12InputConfig, ResolvedConfig, ConfigWatcher, WatchConfigOptions } from 'c12';
-import { ChokidarOptions } from 'chokidar';
-import { DateString, CompatibilityDateSpec, CompatibilityDates } from 'compatx';
-import { ConsolaInstance, LogLevel, ConsolaOptions } from 'consola';
-import { Hookable, NestedHooks } from 'hookable';
-import { Ignore, Options } from 'ignore';
-import { TSConfig } from 'pkg-types';
-import { PresetName, PresetOptions, PresetNameInput } from 'silgi/presets';
-import { ResolvedServiceType as ResolvedServiceType$1, SilgiRuntimeShareds as SilgiRuntimeShareds$1, SilgiRuntimeOptions as SilgiRuntimeOptions$1, RouteRules as RouteRules$1, ModuleMeta as ModuleMeta$1, SilgiModule as SilgiModule$1, SilgiRouteRules as SilgiRouteRules$1, DotenvOptions as DotenvOptions$1, EnvOptions as EnvOptions$1, SilgiRuntimeConfig as SilgiRuntimeConfig$1, ServiceParseModule as ServiceParseModule$1, SilgiCLIHooks as SilgiCLIHooks$1, StorageMounts as StorageMounts$1, SilgiTemplate as SilgiTemplate$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1 } from 'silgi/types';
-import { UnimportPluginOptions } from 'unimport/unplugin';
-import { Defu } from 'defu';
-import { Stats } from 'node:fs';
-import { Unimport } from 'unimport';
-import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { ProviderName } from 'std-env';
-import { s as silgi } from '../shared/silgi.Cs0ZUUXV.js';
-
-type HookResult = Promise<void> | void;
-
-interface SilgiCompatibilityIssue {
-    name: string;
-    message: string;
-}
-interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
-    /**
-     * Return formatted error message.
-     */
-    toString: () => string;
-}
-
-interface ImportItem {
-    importItems: {
-        [key: string]: {
-            import: {
-                type?: boolean;
-                name: string;
-                key: string;
-            }[];
-            from: string;
-        };
-    };
-    customImports: string[];
-    customContent?: string[];
-}
-interface SilgiCommands {
-}
-interface SilgiCLI {
-    _ignore?: Ignore;
-    errors: {
-        type: 'Parser';
-        path?: string;
-    }[];
-    services: ResolvedServiceType$1;
-    shareds: SilgiRuntimeShareds$1;
-    uris: Record<string, any>;
-    schemas: Record<string, any>;
-    modulesURIs: Partial<Record<keyof SilgiRuntimeOptions$1 | (string & {}), any>>;
-    scannedURIs: Map<string, string>;
-    templates: SilgiTemplate[];
-    routeRules: RouteRules$1;
-    hooks: Hookable<SilgiCLIHooks>;
-    hook: SilgiCLI['hooks']['hook'];
-    callHook: SilgiCLI['hooks']['callHook'];
-    addHooks: SilgiCLI['hooks']['addHooks'];
-    storage: Storage;
-    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>;
-    commands: Record<string, Record<string, {
-        type: 'function' | 'command';
-        handler: string;
-        description?: string;
-        tags?: (keyof SilgiCommands)[];
-        enabled?: 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>;
-}
-interface ScanFile {
-    context: string;
-    object: {
-        schemas: any;
-        uris: any;
-        services: any;
-        shareds: any;
-        modulesURIs: any;
-    };
-    path: string;
-}
-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 ResolvedSilgiTemplate<Options = TemplateDefaultOptions> extends SilgiTemplate<Options> {
-    filename: string;
-    dst: string;
-    modified?: boolean;
-}
-
-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;
-    /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
-     */
-    'close': (silgi: SilgiCLI) => HookResult;
-    'reload:scan': (path: string, stats?: Stats) => HookResult;
-    'prepare:createCoreFramework': (options: Pick<ImportItem, 'customImports' | 'importItems'> & {
-        functions?: {
-            name: string;
-            params?: string[];
-        }[];
-    }) => HookResult;
-    'prepare:createDTSFramework': (options: ImportItem) => HookResult;
-    /**
-     * Allows extending compatibility checks.
-     * @param compatibility Compatibility object
-     * @param issues Issues to be mapped
-     * @returns Promise
-     */
-    'kit:compatibility': (compatibility: SilgiCompatibility, issues: SilgiCompatibilityIssues) => 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:types': (options: {
-        references: TSReference[];
-        declarations: string[];
-        tsConfig: TSConfig;
-    }) => HookResult;
-    'prepare:core.ts': (data: PrepareCore) => HookResult;
-    'after:prepare:core.ts': (content: string[]) => HookResult;
-    'prepare:scan.ts': (data: Pick<ImportItem, 'customImports' | 'importItems'> & {
-        uris: Record<string, string>;
-        services: string[];
-        shareds: string[];
-        schemas: string[];
-        modulesURIs: Record<string, string>;
-    }) => HookResult;
-    'after:prepare:scan.ts': (content: string[]) => HookResult;
-    'prepare:schema.ts': (options: {
-        options: {
-            key: string;
-            value: string;
-        }[];
-        runtimeOptions: {
-            key: string;
-            value: string;
-        }[];
-        methods: {
-            key: string;
-            value: string;
-        }[];
-        routeRules: {
-            key: string;
-            value: string;
-        }[];
-        routeRulesConfig: {
-            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 SilgiEvents {}
-             */
-            extends?: boolean;
-            isSilgiContext?: boolean;
-        }[];
-        hooks: {
-            key: string;
-            value: string;
-        }[];
-        runtimeHooks: {
-            key: string;
-            value: string;
-        }[];
-    } & ImportItem) => HookResult;
-    'after:prepare:schema.ts': (content: string[]) => HookResult;
-    'prepare:framework.d.ts': (options: {} & ImportItem) => HookResult;
-    'prepare:configs.ts': (cliOptions: Record<string, any>) => HookResult;
-    /**
-     * 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
-     */
-    'app:templates': (app: SilgiCLI) => HookResult;
-    /**
-     * 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
-     */
-    'app:templatesGenerated': (app: SilgiCLI, templates: ResolvedSilgiTemplate[], options?: GenerateAppOptions) => HookResult;
-    'scanFiles:done': (app: SilgiCLI) => HookResult;
-    'prepare:commands': (commands: SilgiCLI['commands']) => HookResult;
-    'prepare:installPackages': (packages: Record<'dependencies' | 'devDependencies', Record<string, string>>) => HookResult;
-}
-type TSReference = {
-    types: string;
-} | {
-    path: string;
-};
-interface SilgiHooks {
-}
-interface GenerateAppOptions {
-    filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
-}
-interface PrepareCore extends ImportItem {
-    buildSilgiExtraContent: string[];
-    beforeBuildSilgiExtraContent: {
-        value: string;
-        type: 'function' | 'variable';
-    }[];
-    afterCliOptions: string[];
-    _silgiConfigs: any[];
-}
-
-/**
- * Bu nitrojs, h3 event or request context.
- */
-interface SilgiEvents extends Record<string, unknown> {
-}
-
-interface SilgiSchema {
-}
-interface MergedSilgiSchema {
-}
-type BaseSchemaType<T extends StandardSchemaV1> = {
-    [Action in BaseSilgiMethodType]?: Record<string, {
-        input?: T;
-        output?: T;
-        pathParams?: T;
-        queryParams?: T;
-        source?: T;
-    }>;
-};
-
-interface SilgiURIs {
-}
-type URIsTypes<T extends Record<string, string>> = {
-    [K in keyof T]: string;
-};
-type ExtractPath<T extends string> = T extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
-    service: Service;
-    entity: Entity;
-    method: Method;
-    action: Action;
-} : never : never;
-type GetInput<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    input: infer I;
-} ? I extends StandardSchemaV1 ? StandardSchemaV1.InferInput<I> : never : never : never : never : never : never;
-type GetOutput<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    output: infer O;
-} ? O extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<O> : never : never : never : never : never : never;
-type GetSource<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    source: infer I;
-} ? I : never : never : never : never : never;
-type GetQueryParams<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    queryParams: infer Q;
-} ? Q : never : never : never : never : never;
-type GetPathParams<T extends {
-    service: string;
-    entity: string;
-    method: string;
-    action: string;
-}> = T['service'] extends keyof SilgiSchema ? T['entity'] extends keyof SilgiSchema[T['service']] ? T['method'] extends keyof SilgiSchema[T['service']][T['entity']] ? T['action'] extends keyof SilgiSchema[T['service']][T['entity']][T['method']] ? SilgiSchema[T['service']][T['entity']][T['method']][T['action']] extends {
-    pathParams: infer Q;
-} ? Q : never : never : never : never : never;
-type ExtractInputFromURI<TURI extends keyof SilgiURIs> = GetInput<ExtractPath<TURI>>;
-type ExtractSourceFromURI<TURI extends keyof SilgiURIs> = GetSource<ExtractPath<TURI>>;
-type ExtractOutputFromURI<TURI extends keyof SilgiURIs> = GetOutput<ExtractPath<TURI>>;
-type ExtractQueryParamsFromURI<TURI extends keyof SilgiURIs> = GetQueryParams<ExtractPath<TURI>>;
-type ExtractPathParamsFromURI<TURI extends keyof SilgiURIs> = GetPathParams<ExtractPath<TURI>>;
-
-/**
- * @example
- * namespace: 'coreApi'
- * serviceName: 'basket'
- * method: 'post'
- * action: 'createBasket'
- */
-interface SilgiOperation {
-    /**
-     * 'coreApi'
-     * 'storageApi'
-     */
-    namespaceName: keyof DefaultNamespaces;
-    /**
-     * 'basket'
-     * 'user'
-     */
-    serviceName: string;
-    /**
-     * 'post'
-     * 'delete'
-     */
-    methodName: string;
-    /**
-     * 'createBasket'
-     * 'deleteUser'
-     */
-    actionName: string;
-    /**
-     * 'coreApi/basket/post/createBasket'
-     */
-    raw: string;
-    /**
-     * '/book/basket/getAllBaskets'
-     */
-    uri: keyof SilgiURIs;
-    /**
-     * ['coreApi', 'book', 'basket', 'getAllBaskets']
-     */
-    parts: 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>;
-}
-
-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;
-}
-interface ResolvedModuleMeta extends ModuleMeta {
-    configKey: string;
-    name: string;
-}
-type ModuleHookContext = Readonly<{
-    event?: SilgiEvents;
-    operation?: SilgiOperation;
-    input?: unknown;
-    source?: any;
-    result?: unknown;
-    modules?: SilgiRuntimeActions;
-    timestamp?: number;
-    meta?: Record<string, unknown>;
-    error?: Error;
-    success?: boolean;
-    cached?: boolean;
-    config: {
-        returnNull: boolean;
-    };
-}>;
-/** The options received.  */
-type ModuleOptionsCustom = Record<string, any>;
-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 {
-    /**
-     * 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>;
-}
-
-interface SilgiRuntimeMethods {
-}
-interface SilgiNamespaces {
-}
-type CommandType = 'run' | 'prepare' | 'install';
-interface DefaultNamespaces extends SilgiNamespaces {
-}
-interface SilgiRouterTypes {
-}
-type BaseSilgiMethodType = 'post' | 'delete' | 'put' | 'get' | keyof SilgiRuntimeMethods | (string & {});
-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 Awaitable<T> = T | Promise<T>;
-interface CreateScope {
-    execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>) => Promise<ExtractOutputFromURI<TURI>>;
-}
-declare global {
-    var $silgiStatus: CommandType;
-    var $silgiSharedRuntimeConfig: SilgiRuntimeOptions;
-    namespace NodeJS {
-        interface Global {
-            $silgiStatus: CommandType;
-            $silgiSharedRuntimeConfig: SilgiRuntimeOptions;
-        }
-    }
-}
-
-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;
-    };
-    commandType: CommandType;
-    routeRules: SilgiRouteRules$1;
-    environments: DotenvOptions$1[];
-    activeEnvironment: string;
-    envOptions: EnvOptions$1;
-    runtimeConfig: SilgiRuntimeConfig$1 & {
-        [key: string]: any;
-    };
-    serviceParseModules: ServiceParseModule$1[];
-    storages: string[];
-    namespaces: string[];
-    hooks: NestedHooks<SilgiCLIHooks$1>;
-    plugins: {
-        path: string;
-        packageImport: 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: 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[];
-    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;
-    commands: Record<string, Record<string, {
-        type: 'function' | 'command';
-        handler: string;
-        description?: string;
-    }>>;
-    installPackages: Record<'dependencies' | 'devDependencies', Record<string, string>>;
-}
-/**
- * Silgi input config (silgi.config)
- */
-interface SilgiCLIConfig extends DeepPartial<Omit<SilgiCLIOptions, 'preset' | 'compatibilityDate' | '_config' | '_c12'>>, 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;
-}
-
-interface EnvOptions {
-    prefix?: string;
-    altPrefix?: string;
-    silgiPrefix?: string;
-    envExpansion?: boolean;
-}
-
-interface DefaultRouteConfig extends SilgiRuntimeRouteRulesConfig {
-    splat?: boolean;
-    doubleSplat?: boolean;
-    [key: string]: any;
-}
-interface DefaultRouteRules extends SilgiRuntimeRouteRules {
-    [key: string]: any;
-}
-type SilgiRouteRules = Record<DefaultRouteRules extends string ? DefaultRouteRules : string, DefaultRouteConfig>;
-interface SilgiRuntimeRouteRules {
-}
-interface SilgiRuntimeRouteRulesConfig {
-}
-/**
- * Interface for the object returned by createRouteRules
- */
-interface RouteRules {
-    readonly rules: Record<string, DefaultRouteConfig>;
-    readonly mergedRules: Record<string, DefaultRouteConfig>;
-    importRules: (config: Record<string, DefaultRouteConfig>) => void;
-    exportRules: () => Record<string, DefaultRouteConfig>;
-    addRule: (pattern: string, config: DefaultRouteConfig) => void;
-    updateRule: (pattern: string, config: Partial<DefaultRouteConfig>) => void;
-    removeRule: (pattern: string) => void;
-    matchesRule: (url: string, pattern: string) => boolean;
-    getMatchingPatterns: (url: string) => string[];
-    getConfig: (url: string) => DefaultRouteConfig | null;
-    getParams: (url: string, pattern: string) => Record<string, string> | null;
-    match: (url: string) => {
-        pattern: string;
-        config: DefaultRouteConfig;
-        params: Record<string, string> | null;
-    } | null;
-    clear: () => void;
-    clearMergedRules: () => void;
-    precomputeMergedRules: (urls: string[]) => void;
-    setMergedRule: (url: string, config: DefaultRouteConfig) => void;
-    getMergedRules: () => Record<string, DefaultRouteConfig>;
-    configure: (config: Record<string, DefaultRouteConfig>) => void;
-    updateMergeRules: () => Record<string, DefaultRouteConfig>;
-}
-
-type CustomDriverName = string & {
-    _custom?: any;
-};
-interface StorageMounts {
-    [path: string]: {
-        driver: BuiltinDriverName | CustomDriverName;
-        [option: string]: any;
-    };
-}
-interface SilgiStorageBase {
-}
-type StorageKeyGenerator<TInput> = (input: TInput) => string | Promise<string>;
-interface StorageConfig<TInput> {
-    options: TransactionOptions;
-    base: 'memory' | keyof SilgiStorageBase;
-    key?: StorageKeyGenerator<TInput>;
-    scope?: 'request' | 'global';
-}
-interface StorageKeyParams<TInput = unknown> {
-    operation: SilgiOperation;
-    input: TInput;
-    requestId?: string;
-    keyGenerator?: StorageKeyGenerator<TInput>;
-    storageOptions?: Pick<StorageConfig<TInput>, 'base' | 'options' | 'scope'>;
-}
-
-interface SilgiRuntimeShareds extends SilgiRuntimeSharedsExtend {
-    storage: <T extends StorageValue = StorageValue>(base: StorageConfig<T>['base']) => Storage<T>;
-    silgi: SilgiFunction;
-    runtimeConfig: SilgiRuntimeConfig;
-}
-interface SilgiRuntimeSharedsExtend {
-}
-interface ExtendShared {
-}
-
-type EventHandlerResponse<T = undefined> = T extends undefined ? void : void | T | Promise<T>;
-type MethodHandlerType<T> = {
-    routeRules?: DefaultRouteConfig;
-} & {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        routeRules?: DefaultRouteConfig;
-    } & {
-        [Method in keyof T[Action]]?: {
-            default?: {
-                input?: StandardSchemaV1.InferInput<T[Action][Method]['input']> & {
-                    parameters: StandardSchemaV1.InferInput<T[Action][Method]['pathParams']> & StandardSchemaV1.InferInput<T[Action][Method]['queryParams']>;
-                };
-                output?: StandardSchemaV1.InferInput<T[Action][Method]['output']>;
-                source?: StandardSchemaV1.InferInput<T[Action][Method]['source']>;
-            };
-            handler: (input: StandardSchemaV1.InferInput<T[Action][Method]['input']> & {
-                parameters: StandardSchemaV1.InferInput<T[Action][Method]['pathParams']> & StandardSchemaV1.InferInput<T[Action][Method]['queryParams']>;
-            }, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<T[Action][Method]['source']>) => EventHandlerResponse<StandardSchemaV1.InferOutput<T[Action][Method]['output']>>;
-            modules?: Partial<SilgiRuntimeActions>;
-            routeRules?: DefaultRouteConfig;
-            storage?: StorageConfig<T[Action][Method]['input']>;
-        };
-    } : never;
-};
-interface ResolvedMethodHandlerType {
-    input?: Partial<BaseSchemaType<any>>;
-    output: Partial<BaseSchemaType<any>>;
-    handler: (input: StandardSchemaV1.InferInput<any> & {
-        parameters: any;
-    }, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<any>) => Promise<StandardSchemaV1.InferInput<any>>;
-    modules?: Partial<SilgiRuntimeActions>;
-    storage?: StorageConfig<StandardSchemaV1.InferInput<any>>;
-    routeRules?: SilgiRouteRules;
-    execute: (input: StandardSchemaV1.InferInput<any>, shared: SilgiRuntimeShareds, event: SilgiEvents, source: StandardSchemaV1.InferInput<any>) => Promise<StandardSchemaV1.InferInput<any>>;
-}
-
-type SilgiServiceInterface<T extends BaseSchemaType<StandardSchemaV1>> = {
-    [Action in keyof T]: T[Action] extends Record<string, any> ? {
-        [Method in keyof T[Action]]: {
-            input: T[Action][Method]['input'];
-            output: T[Action][Method]['output'];
-            /**
-             * Example: /api/v1/users/{id}/{name}/{surname}
-             */
-            pathParams: T[Action][Method]['pathParams'];
-            /**
-             * Example: /api/v1/users?name=ali&surname=veli
-             */
-            queryParams: T[Action][Method]['queryParams'];
-            source: T[Action][Method]['source'];
-        };
-    } : never;
-};
-type ServiceType<T> = Partial<{
-    [Namespace in keyof T]: T[Namespace] extends Record<string, any> ? {
-        routeRules?: DefaultRouteConfig;
-    } & {
-        [Service in keyof T[Namespace]]?: Partial<MethodHandlerType<T[Namespace][Service]>>;
-    } : never;
-}>;
-type RequiredServiceType<T> = {
-    [K in keyof T]-?: T[K] extends Record<string, any> ? {
-        [P in keyof T[K]]-?: MethodHandlerType<T[K][P]>;
-    } : never;
-};
-/**
- * const test: ResolvedServiceType = {
-  aaa: {
-    bbb: {
-      delete: {
-        storage: {
-          handler: () => {}
-        },
-      },
-    },
-  },
-}
- */
-type ResolvedServiceType = {
-    [K in string]: {
-        [P in string]: {
-            [Q in BaseSilgiMethodType]?: {
-                [M in string]: ResolvedMethodHandlerType;
-            };
-        };
-    };
-};
-
-interface FrameworkContext {
-}
-interface Silgi {
-    schemas: any;
-    services: ResolvedServiceType;
-    shared: SilgiRuntimeShareds;
-    uris: Record<string, any>;
-    modulesURIs: Partial<Record<keyof SilgiRuntimeOptions | (string & {}), any>>;
-    scannedHandlers: Map<string, ResolvedMethodHandlerType>;
-    plugins: SilgiAppPlugin[];
-    framework: FrameworkContext;
-    routeRules: RouteRules;
-    _ignore?: Ignore;
-    hooks: Hookable<SilgiRuntimeHooks & DefaultHooks>;
-    hook: Silgi['hooks']['hook'];
-    callHook: Silgi['hooks']['callHook'];
-    addHooks: Silgi['hooks']['addHooks'];
-    ready: () => Promise<void>;
-    close: () => Promise<void>;
-    logger: ConsolaInstance;
-    storage: Storage;
-    envOptions: EnvOptions;
-    options: SilgiOptions & SilgiRuntimeOptions;
-    captureError: CaptureError;
-}
-interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRuntimeOptions> {
-    options: DeepPartial<SilgiOptions>;
-}
-type SilgiFunction = typeof silgi;
-
-interface SilgiAppPlugin {
-    (silgi: Silgi): Promise<void> | void;
-}
-
-interface CapturedErrorContext {
-    event?: SilgiEvents;
-    [key: string]: unknown;
-}
-type CaptureError = (error: Error, context: CapturedErrorContext) => void;
-
-/**
- * The listeners to Silgi
- */
-interface SilgiRuntimeHooks {
-    /**
-     * Called after Silgi initialization, when the Silgi instance is ready to work.
-     * @param silgi The configured Silgi object
-     * @returns Promise
-     */
-    'ready': (silgi: Silgi) => HookResult;
-    /**
-     * Called when silgi instance is gracefully closing.
-     * @param silgi The configured silgi object
-     * @returns Promise
-     */
-    'close': (silgi: Silgi) => HookResult;
-    'app:setup:start': (silgi: Silgi) => HookResult;
-    'execute:before': (context: ModuleHookContext) => HookResult;
-    'execute:after': (context: ModuleHookContext) => HookResult;
-    'execute:error': (context: ModuleHookContext) => HookResult;
-    'execute:finally': (context: ModuleHookContext) => HookResult;
-    'event:init': (event: SilgiEvents, data: {
-        path: string;
-        queryParams?: Record<string, string>;
-        operation: SilgiOperation;
-    }) => HookResult;
-    'error': CaptureError;
-}
-
-interface SilgiRuntimeConfig {
-}
-interface SilgiOptions {
-    consolaOptions?: Partial<ConsolaOptions>;
-    routeRules: SilgiRouteRules;
-    present: PresetNameInput;
-    hooks: Partial<SilgiRuntimeHooks & DefaultHooks>;
-    /**
-     * Set to `true` to enable debug mode.
-     *
-     * At the moment, it prints out hook names and timings on the server, and logs hook arguments as well in the browser.
-     *
-     * @default false
-     */
-    debug: boolean;
-    storage: StorageMounts;
-    putStorage?: Storage<StorageValue>;
-    runtimeConfig: SilgiRuntimeConfig & {
-        [key: string]: any;
-    };
-    captureError: CaptureError;
-    [key: string]: any;
-}
-
-interface SilgiRuntimeContext extends Record<string, any> {
-}
-interface ExtendContext {
-}
-
-interface DotenvOptions {
-    /**
-     * The project root directory (either absolute or relative to the current working directory).
-     */
-    cwd: string;
-    /**
-     * What file to look in for environment variables (either absolute or relative
-     * to the current working directory). For example, `.env`.
-     */
-    fileName?: string;
-    /**
-     * Whether to interpolate variables within .env.
-     *
-     * @example
-     * ```env
-     * BASE_DIR="/test"
-     * # resolves to "/test/further"
-     * ANOTHER_DIR="${BASE_DIR}/further"
-     * ```
-     */
-    interpolate?: boolean;
-    /**
-     * An object describing environment variables (key, value pairs).
-     */
-    env?: NodeJS.ProcessEnv;
-}
-
-interface GraphQLJSON {
-    queries: any;
-    mutations: any;
-    types: any;
-    inputs: any;
-    references: any;
-}
-
-interface BaseNamespaceType extends Record<keyof DefaultNamespaces, Record<string, BaseSchemaType<StandardSchemaV1>>> {
-}
-type Namespaces<T extends BaseNamespaceType> = {
-    [K in keyof T]: {
-        [P in keyof T[K]]: T[K][P] extends BaseSchemaType<StandardSchemaV1> ? SilgiServiceInterface<T[K][P]> : never;
-    };
-};
-
-interface ServiceParse {
-    node: ResolvedMethodHandlerType;
-    basePath: string;
-    silgi: SilgiCLI;
-    modulesURIs: Record<string, Record<string, any>>;
-    pathLength: number;
-}
-interface ServiceParseModule {
-    (params: ServiceParse): Awaited<void> | void;
-}
-
-declare const autoImportTypes: string[];
-
-export { autoImportTypes };
-export type { AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, CaptureError, CapturedErrorContext, CommandType, CreateScope, DeepPartial, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenerateAppOptions, GraphQLJSON, HookResult, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, PrepareCore, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, URIsTypes };