@orieljs/framework 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/index.d-DOlTeG-8.d.ts

@@ -1,99 +0,0 @@
-import { Token as Token$1 } from './contracts.js';
-
-/** A typed, runtime-unique key for container bindings. */
-interface Token<T> {
-    readonly id: symbol;
-    readonly description: string;
-    /** Phantom field: only carries T at the type level. Never set at runtime. */
-    readonly __type?: T;
-}
-type Class<T> = abstract new (...args: any[]) => T;
-type Abstract<T> = Token<T> | Class<T>;
-type Factory<T> = (container: Container) => T;
-type Concrete<T> = Factory<T> | (new () => T);
-interface Container {
-    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
-    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
-    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
-    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
-    instance<T>(abstract: Abstract<T>, instance: T): T;
-    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
-    make<T>(abstract: Abstract<T>): T;
-    bound(abstract: Abstract<unknown>): boolean;
-    resolved(abstract: Abstract<unknown>): boolean;
-    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
-    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container) => T): void;
-    /** Called after each resolution of the abstract. Root only; throws on a scope. */
-    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container) => void): void;
-    forgetInstance(abstract: Abstract<unknown>): void;
-    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
-    createScope(): Container;
-    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
-    run<R>(fn: () => R): R;
-}
-declare const Container: Token<Container>;
-
-interface ServiceProvider {
-    /** Bind things into the container. Synchronous. Don't resolve other services here. */
-    register?(): void;
-    /** Runs after every provider is registered. May be async (e.g. importing route files). */
-    boot?(): void | Promise<void>;
-}
-type ServiceProviderClass = new (app: Application) => ServiceProvider;
-interface Application extends Container {
-    readonly version: string;
-    basePath(path?: string): string;
-    appPath(path?: string): string;
-    bootstrapPath(path?: string): string;
-    configPath(path?: string): string;
-    databasePath(path?: string): string;
-    publicPath(path?: string): string;
-    resourcePath(path?: string): string;
-    storagePath(path?: string): string;
-    /** With no args returns the environment name. With args returns whether it matches any of them. */
-    environment(): string;
-    environment(...environments: string[]): boolean;
-    isProduction(): boolean;
-    isLocal(): boolean;
-    runningInConsole(): boolean;
-    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
-    setRunningInConsole(value?: boolean): void;
-    runningUnitTests(): boolean;
-    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
-    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
-    getProviders(): ServiceProvider[];
-    boot(): Promise<void>;
-    isBooted(): boolean;
-    booting(callback: (app: Application) => void | Promise<void>): void;
-    booted(callback: (app: Application) => void | Promise<void>): void;
-    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
-    handle(request: Request): Promise<Response>;
-    /** Register a callback that terminate() runs, in registration order. */
-    terminating(callback: () => void | Promise<void>): void;
-    terminate(): Promise<void>;
-}
-declare const Application: Token$1<Application>;
-
-interface ConfigRepository {
-    has(key: string): boolean;
-    /** Dot notation: get('database.connections.sqlite.database'). */
-    get<T = unknown>(key: string, defaultValue?: T): T;
-    set(key: string, value: unknown): void;
-    set(values: Record<string, unknown>): void;
-    push(key: string, value: unknown): void;
-    all(): Record<string, unknown>;
-}
-declare const ConfigRepository: Token$1<ConfigRepository>;
-interface ClassRegistry {
-    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
-    register(cls: Class<unknown>, name?: string): string;
-    nameOf(cls: Class<unknown>): string | undefined;
-    resolve<T = unknown>(name: string): Class<T>;
-    has(name: string): boolean;
-}
-declare const ClassRegistry: Token$1<ClassRegistry>;
-
-export { Application as A, ClassRegistry as C, type ServiceProvider as S, type Class as a, type Abstract as b, ConfigRepository as c };