silgi 0.0.14 → 0.1.2

package/dist/shared/silgi.BaeZYxPa.d.mts

@@ -0,0 +1,871 @@
+import { ConsolaOptions, ConsolaInstance } from 'consola';
+import { Hookable } from 'hookable';
+import { Ignore } from 'ignore';
+import { BuiltinDriverName, TransactionOptions, StorageValue, Storage } from 'unstorage';
+import { Defu } from 'defu';
+import { Router, H3Event } from 'h3';
+import { TSConfig } from 'pkg-types';
+import { z } from 'zod';
+import { NitroApp } from 'nitropack/types';
+
+interface SilgiEvent extends Record<string, unknown> {
+}
+
+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 SilgiServiceTypes ? T['entity'] extends keyof SilgiServiceTypes[T['service']] ? T['method'] extends keyof SilgiServiceTypes[T['service']][T['entity']] ? T['action'] extends keyof SilgiServiceTypes[T['service']][T['entity']][T['method']] ? SilgiServiceTypes[T['service']][T['entity']][T['method']][T['action']]['input'] : never : never : never : never;
+type GetOutput<T extends {
+    service: string;
+    entity: string;
+    method: string;
+    action: string;
+}> = T['service'] extends keyof SilgiServiceTypes ? T['entity'] extends keyof SilgiServiceTypes[T['service']] ? T['method'] extends keyof SilgiServiceTypes[T['service']][T['entity']] ? T['action'] extends keyof SilgiServiceTypes[T['service']][T['entity']][T['method']] ? SilgiServiceTypes[T['service']][T['entity']][T['method']][T['action']]['output'] : never : never : never : never;
+type ExtractInputFromURI<TURI extends keyof SilgiURIs> = GetInput<ExtractPath<TURI>>;
+type ExtractOutputFromURI<TURI extends keyof SilgiURIs> = GetOutput<ExtractPath<TURI>>;
+
+interface SilgiHook {
+}
+interface SilgiServiceTypes {
+}
+interface MergeSilgiType {
+}
+interface DefaultHooks {
+}
+interface DefaultMethods {
+    get: string;
+    post: string;
+    put: string;
+    delete: 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;
+}
+
+interface SilgiMethods {
+}
+interface SilgiNamespaces {
+}
+type BaseSilgiMethodType = 'post' | 'delete' | 'put' | 'get' | keyof SilgiMethods;
+interface DefaultNamespaces extends SilgiNamespaces {
+}
+
+interface SilgiValidationSchema {
+}
+type ValidationLibrary = 'zod' | 'yup';
+type SelectedValidationLibrary = SilgiValidationSchema extends {
+    validationLibrary: infer V;
+} ? V extends ValidationLibrary ? V : 'zod' : 'zod';
+/**
+ * A map of validation library names to their type definitions.
+ *
+ * @see {@link https://zod.dev/ | Zod}
+ * @see {@link https://github.com/jquense/yup | Yup}
+ */
+interface SchemaTypes {
+    zod: z.ZodTypeAny;
+    yup: any;
+}
+type InferSchemaType<V extends SelectedValidationLibrary, T> = V extends 'zod' ? T extends z.ZodTypeAny ? z.infer<T> : never : V extends 'yup' ? any : never;
+type BaseSchemaType<V extends SelectedValidationLibrary> = {
+    [Action in BaseSilgiMethodType]?: Record<string, {
+        input?: SchemaTypes[V];
+        output?: SchemaTypes[V];
+    }>;
+};
+
+/**
+ * @example
+ * namespace: 'coreApi'
+ * serviceName: 'basket'
+ * action: 'post'
+ * method: '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: keyof SilgiURIs;
+    parts: string[];
+}
+
+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:cache' | keyof SilgiStorageBase;
+    key?: StorageKeyGenerator<TInput>;
+    scope?: 'request' | 'global';
+}
+
+interface SilgiEventContext {
+    _context: any;
+    silgi: Silgi;
+    namespace?: string;
+    serviceName?: string;
+    methodName?: string;
+}
+interface SilgiOptions {
+    /**
+     * @default 'nitrojs'
+     */
+    environment?: ('nitrojs' | 'h3' | 'undefined');
+    validationLibrary?: ValidationLibrary;
+    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[];
+    /**
+     *
+     * @private
+     */
+    _silgiConfigFile: any;
+    /**
+     *
+     * @private
+     */
+    _silgiConfigFiles: Array<any>;
+    /**
+     * 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 () {}
+     * ]
+     * ```
+     */
+    modules: (SilgiModule<any> | string | [SilgiModule | string, Record<string, any>] | undefined | null | false)[];
+    modulesDir: Array<string>;
+    /**
+     *
+     * @private
+     */
+    _installedModules: Array<{
+        meta: ModuleMeta;
+        timings?: Record<string, number | undefined>;
+        entryPath?: string;
+        packageName: string;
+        active?: boolean;
+    }>;
+    silgiDir: string;
+    /**
+     *
+     * @private
+     */
+    _modules: Array<any>;
+    /**
+     * `future` is for early opting-in to new features that will become default in a future (possibly major) version of the framework.
+     *
+     */
+    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;
+    };
+    /**
+     * 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)
+         *
+         * @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;
+    };
+    /**
+     * 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"
+         */
+        modules: string;
+        /**
+         * The shared directory. This directory is shared between the app and the server.
+         *
+         * @default "/<rootDir>/shared"
+         */
+        shared: string;
+        /**
+         * 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"
+         */
+        public: 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","**\/-*.*"]
+     */
+    ignore: Array<string>;
+    helper: SilgiHelper;
+    storage: StorageMounts;
+    [key: string]: any;
+}
+
+type HookResult = Promise<void> | void;
+type TSReference = {
+    types: string;
+} | {
+    path: string;
+};
+/**
+ * The listeners to Silgi
+ */
+interface SilgiHooks {
+    /**
+     * 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;
+    'method:before': (context: ModuleHookContext) => HookResult;
+    'method:after': (context: ModuleHookContext) => HookResult;
+    'method:error': (context: ModuleHookContext) => HookResult;
+    'method:finally': (context: ModuleHookContext) => HookResult;
+    'module:register:before': (module: SilgiModule) => HookResult;
+    'module:register:after': (module: SilgiOptions['_installedModules'][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;
+    /**
+     * 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;
+    /**
+     * 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[];
+        types: string[];
+        modules: string[];
+    }) => HookResult;
+    'prepare:schema.ts': (options: {
+        importedItems: {
+            [key: string]: {
+                import: {
+                    type?: boolean;
+                    name: string;
+                }[];
+                from: string;
+            };
+        };
+        imports: string[];
+        configs: {
+            key: string;
+            value: string;
+        }[];
+        contexts: {
+            key: string;
+            value: string;
+        }[];
+        methods: {
+            key: string;
+            value: string;
+        }[];
+        shareds: {
+            key: string;
+            value: string;
+        }[];
+        events: {
+            key: string;
+            value: string;
+            extends?: boolean;
+            isSilgiContext?: boolean;
+        }[];
+        storeBase: string[];
+    }) => HookResult;
+    'prepare:h3.d.ts': (options: {
+        importedItems: {
+            [key: string]: {
+                import: {
+                    type?: boolean;
+                    name: string;
+                }[];
+                from: string;
+            };
+        };
+        imports: string[];
+    }) => HookResult;
+    'read:core.ts': (data: () => Awaitable<{
+        context: string;
+        object: {
+            uris?: string[];
+            services?: string[];
+            shareds?: string[];
+        };
+        path: string;
+    }>) => HookResult;
+}
+
+interface SilgiModules {
+}
+interface SilgiModuleMethods {
+}
+interface SilgiModuleOptions {
+}
+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;
+    /** exports */
+    exports?: {
+        interface?: {
+            config?: true;
+            shared?: true;
+            context?: true;
+            method?: true;
+            event?: true;
+        };
+        variable?: {
+            shared?: true;
+        };
+    };
+    /** 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;
+    readonly dependencies?: ReadonlyArray<string>;
+    [key: string]: unknown;
+}
+type ModuleHookContext = Readonly<{
+    event?: SilgiEvent;
+    operation?: SilgiOperation;
+    input?: unknown;
+    result?: unknown;
+    modules?: ModuleConfigurations;
+    config?: unknown;
+    timestamp?: number;
+    meta?: Record<string, unknown>;
+    error?: Error;
+    hookName?: string;
+    success?: boolean;
+}>;
+/** The options received.  */
+type ModuleOptions = Record<string, any>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ResolvedModuleOptions<TOptions extends ModuleOptions, TOptionsDefaults extends Partial<TOptions>> = Prettify<Defu<Partial<TOptions>, [
+    Partial<TOptions>,
+    TOptionsDefaults
+]>>;
+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;
+}
+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 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>;
+    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?: T[Action][Method]['input'] extends infer U ? U : never;
+                output?: T[Action][Method]['output'] extends infer U ? U : never;
+            };
+            handler: (input: T[Action][Method]['input'], shared: SilgiDefaultShared, event: SilgiEvent) => EventHandlerResponse<T[Action][Method]['output'] extends infer U ? U : undefined>;
+            modules?: ModuleConfigurations;
+            storage?: StorageConfig<T[Action][Method]['input']>;
+        };
+    } : never;
+};
+interface ResolvedMethodHandlerType {
+    input?: Partial<InferSchemaType<SelectedValidationLibrary, any>>;
+    output: Partial<InferSchemaType<SelectedValidationLibrary, any>>;
+    handler: (input: InferSchemaType<SelectedValidationLibrary, any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<InferSchemaType<SelectedValidationLibrary, any>>;
+    modules?: ModuleConfigurations;
+    storage?: StorageConfig<InferSchemaType<SelectedValidationLibrary, any>>;
+    execute: (input: InferSchemaType<SelectedValidationLibrary, any>, shared: SilgiDefaultShared, event: SilgiEvent) => Promise<InferSchemaType<SelectedValidationLibrary, 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<(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["service"] extends never ? (TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["entity"] extends keyof SilgiServiceTypes[(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["service"]] ? (TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["method"] extends keyof SilgiServiceTypes[(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["service"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["entity"]] ? (TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["action"] extends keyof SilgiServiceTypes[(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["service"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["entity"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["method"]] ? SilgiServiceTypes[(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["service"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["entity"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["method"]][(TURI extends `${infer Path}` ? Path extends `${infer Service}/${infer Entity}/${infer Method}/${infer Action}` ? {
+        service: Service;
+        entity: Entity;
+        method: Method;
+        action: Action;
+    } : never : never)["action"]]["output"] : never : never : never : never>>;
+};
+
+type SilgiServiceInterface<T extends BaseSchemaType<SelectedValidationLibrary>> = {
+    [Action in keyof T]: T[Action] extends Record<string, any> ? {
+        [Method in keyof T[Action]]: {
+            input: InferSchemaType<SelectedValidationLibrary, T[Action][Method]['input']>;
+            output?: InferSchemaType<SelectedValidationLibrary, T[Action][Method]['output']>;
+        };
+    } : 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 {
+    types: 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' | 'types' | '_initializedModules'> {
+    options: DeepPartial<SilgiOptions>;
+}
+type SilgiFunction = typeof silgi;
+
+export { type Awaitable as A, type BaseSchemaType as B, type CreateScope as C, type DeepPartial as D, type ExtendShared as E, type ModuleOptions as M, type RequiredServiceType as R, type SilgiOptions as S, type URIsTypes as U, type ValidationLibrary as V, type SilgiModuleOptions as a, type SilgiConfig as b, SilgiHelper as c, type ModuleDefinition as d, type SilgiModule as e, type SelectedValidationLibrary as f, type SilgiServiceInterface as g, type DefaultNamespaces as h, type Silgi as i, type SilgiOperation as j, type MergeSilgiType as k, type ServiceType as l, type SilgiServiceTypes as m, type SilgiModuleShared as n, type SilgiEvent as o, type SilgiModuleMethods as p, type SilgiModules as q, type SilgiNamespaces as r, type SilgiValidationSchema as s, type SilgiDefaultShared as t, type SilgiURIs as u, type SilgiStorageBase as v, silgi as w, type SilgiHook as x, type DefaultMethods as y, type DefaultHooks as z };