export class ObjectPrototype<T> {
    __implements__: (typeof MarkerInterface | typeof ObjectInterface)[];
    constructor(data?: T);
    toJSON(): T;
}
export type TUtilityProps = {
    name?: string;
    registry?: TUtilityRegistry;
};
export class Utility<TUtility> {
    static __implements__: typeof UtilityInterface;
    static __name__: string;
}
export class UtilityNotFound {
}
type TUtilityEntry = {
    implementsInterface: UtilityInterface;
    unnamedUtility: Utility<any>[] | undefined;
    namedUtility: Record<string, Utility<any>>;
};
export type TUtilityRegistry = {
    utilities: Record<string, TUtilityEntry>;
    registerUtility(utility: Utility<any>): void;
    getUtility<T = any>(implementsInterface: UtilityInterface, name?: string, fallbackReturnValue?: any): Utility<T>;
    getUtilities<T = any>(implementsInterface: UtilityInterface): Utility<T>[];
};
export class UtilityRegistry implements TUtilityRegistry {
    utilities: any;
    register: Function;
    constructor();
    registerUtility(utility: any): void;
    getUtility<T = any>(implementsInterface: any, name?: any): Utility<T>;
    getUtilities<T extends UtilityInterface = any>(implementsInterface: any): Utility<T>[];
}
export function createInterfaceDecorator(namespace: string): (intrfc: any) => void;
export class MarkerInterface {
    static interfaceId: string;
    static providedBy(obj: ObjectPrototype<any>): boolean;
    providedBy(obj: ObjectPrototype<any>, interfaceId?: string): boolean;
}
export type TypeFromInterface<T> = Omit<T, 'interfaceId' | 'providedBy'>;
export class ObjectInterface {
    static interfaceId: string;
    constructor(context: ObjectPrototype<any>);
    static providedBy(obj: ObjectPrototype<any>): boolean;
    providedBy(obj: ObjectPrototype<any>, interfaceId?: string): boolean;
}
export class AdapterInterface {
    static interfaceId: string;
    context?: ObjectPrototype<any>;
    constructor(context: ObjectPrototype<any>, registry?: TAdapterRegistry);
}
export class UtilityInterface {
    static interfaceId: string;
    static __name__: string;
    constructor(nameOrRegistry?: string | TUtilityRegistry, registry?: TUtilityRegistry);
}
type TAdapter<T> = {
    context: T;
};
export abstract class Adapter<TContext = ObjectPrototype<any>> implements TAdapter<TContext> {
    static __implements__: typeof AdapterInterface;
    static __adapts__: typeof ObjectPrototype<any> | ObjectInterface | MarkerInterface;
    context: TContext;
    constructor(context: TContext);
}
export class AdapterNotFound {
}
type TAdapterEntry = {
    interfaceAdapters: Adapter<any>[];
    objectAdapters: Adapter<any>[];
};
export type TAdapterRegistry = {
    adapters: Record<string, TAdapterEntry>;
    registerAdapter(adapter: Adapter<any>): void;
    getAdapter(obj: ObjectPrototype<any> | typeof ObjectInterface | typeof MarkerInterface, implementsInterface: AdapterInterface | typeof AdapterInterface): Adapter<any>;
    register: Function;
};
export class AdapterRegistry implements TAdapterRegistry {
    adapters: any;
    registerAdapter: any;
    getAdapter: any;
    register: Function;
    constructor();
}
export type TRegistry = TUtilityRegistry & TAdapterRegistry;
export class LocalRegistry extends UtilityRegistry implements TRegistry {
    utilities: any;
    adapters: any;
    registerAdapter: any;
    registerUtility: any;
    getAdapter: any;
    getUtility: any;
    getUtilities: any;
    constructor();
}
export const globalRegistry: TRegistry & {
    register: Function;
};

//# sourceMappingURL=types.d.ts.map