import type { GGLocatorKey } from "./GGLocatorKey";
import { GGLocatorScopeDebug, GGLocatorScopeDebugList } from "./GGLocatorScopeDebug";
import { type Values } from "@grest-ts/common";
type ConstructorOf<T> = new (...args: any[]) => T;
/**
 * service-locator pattern for async context cases.
 */
export declare class GGLocatorScope {
    readonly name: string;
    readonly serviceName: string;
    private readonly parent;
    private readonly values;
    private readonly registrationStacks;
    private readonly creationStack;
    constructor(name: string, parent?: GGLocatorScope, serviceName?: string);
    private _get;
    get<T>(token: GGLocatorKey<T>): T;
    tryGet<T>(token: GGLocatorKey<T>): T | undefined;
    getByTokenName<T>(name: string, type: ConstructorOf<T>): T;
    set<T>(token: GGLocatorKey<T>, value: T): void;
    overwrite<T>(token: GGLocatorKey<T>, value: T): void;
    has<T>(token: GGLocatorKey<T>): boolean;
    /**
     * Returns all registered key names in this scope.
     * Used by testkit to report available services to test runner.
     */
    getKeys(): string[];
    private _lifecycleHandler?;
    setLifecycleOwner(handler: ((service: GGLocatorLifecycleCallbacks) => void) | undefined): void;
    setWithLifecycle<T>(token: GGLocatorKey<T>, value: T, lifecycle: GGLocatorLifecycleCallbacks): void;
    setImmediate<R>(fn: () => R): NodeJS.Immediate;
    setTimeout<R>(fn: () => R, timeout: number): NodeJS.Timeout;
    setInterval<R>(fn: () => R, timeout: number): NodeJS.Timeout;
    /**
     * Wraps a function with a async context run() call. Safe for most cases.
     * Consider wrapWithEnter in case you want same context for that function forever.
     */
    wrapWithRun<T extends (...args: any[]) => any>(fn: T): T;
    /**
     * Wraps function to ensure this scope is active before each call.
     * Unlike wrapWithRun, doesn't create a new async boundary - just ensures scope is entered.
     * More performant for high-frequency event handlers where scope doesn't change.
     */
    wrapWithEnter<T extends (...args: any[]) => any>(fn: T): T;
    getScopeDebug(): GGLocatorScopeDebug;
    getScopeDebugFull(list?: GGLocatorScopeDebugList): GGLocatorScopeDebugList;
    branch(name: string, serviceName?: string): GGLocatorScope;
    run<R>(fn: () => R): R;
    enter(): this;
    ensureEntered(): void;
    reset(): void;
}
/**
 * Service initialization order - determines the sequence in which services start and stop.
 * Services with lower values start first and stop last (reverse order for teardown).
 *
 * Example startup order: CONFIG → DATABASE → HTTP → INTL → BUSINESS → PERIODIC_JOBS → SERVICE_DISCOVERY
 */
export declare const GGLocatorServiceType: Readonly<{
    readonly CONFIG: 0;
    readonly DATABASE: 10;
    readonly HTTP: 20;
    readonly INTL: 25;
    readonly BUSINESS: 30;
    readonly PERIODIC_JOBS: 40;
    readonly SERVICE_DISCOVERY: 999;
}>;
export type GGLocatorServiceType = Values<typeof GGLocatorServiceType>;
/**
 * Service lifecycle callbacks registered with GGServiceRegistry.
 *
 * Services register these during construction (in GGRuntime.compose) to participate
 * in the runtime lifecycle - startup, teardown, and per-request context hooks.
 */
export interface GGLocatorLifecycleCallbacks {
    type: GGLocatorServiceType | (number & {});
    start: () => any | Promise<any>;
    teardown?: () => any | Promise<any>;
}
export {};
//# sourceMappingURL=GGLocatorScope.d.ts.map