import type { IDataSource } from '../../../base/datasources';
import type { AbstractEntity } from '../../../base/models';
import type { AnyType, TClass, TMixinTarget } from '@venizia/ignis-helpers/common';
import type { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
import type { IModelMetadata, IModelRegistryEntry, IRepositoryBinding, IResolvedRepositoryMetadata, TRepositoryMetadata } from '../common/types';
export declare const RepositoryMetadataMixin: <BaseClass extends TMixinTarget<_MetadataRegistry & {
    modelRegistry: Map<string, IModelRegistryEntry>;
    getModelMetadata(opts: {
        target: object;
    }): IModelMetadata | undefined;
}>>(baseClass: BaseClass) => {
    new (...args: any[]): {
        /** By repository class name, for the by-name API. Two classes may share a name; `repositoryBindingsByClass` cannot confuse them. */
        repositoryBindings: Map<string, IRepositoryBinding<AbstractEntity>>;
        /** By repository class: a minified build renames classes, and two chunks may give two of them one name. */
        repositoryBindingsByClass: Map<Function, IRepositoryBinding<AbstractEntity>>;
        /**
         * The model classes each datasource owns, keyed by the datasource class - or by the string a
         * repository named it with (`dataSource: 'PgDataSource'`), which only a class of that name
         * can match. Never by class name alone: a minified build gives two datasources one name.
         */
        datasourceModels: Map<string | Function, Set<TClass<AnyType>>>;
        setRepositoryMetadata<Target extends object = object, Model extends AbstractEntity = AbstractEntity<unknown>, DataSource extends IDataSource = IDataSource<{}, import("../../../base/datasources").TAnyDataSourceSchema, {}>>(opts: {
            target: Target;
            metadata: TRepositoryMetadata<Model, DataSource> & {
                _resolved?: IResolvedRepositoryMetadata<Model, DataSource>;
            };
        }): void;
        getRepositoryMetadata<Target extends object = object>(opts: {
            target: Target;
        }): (TRepositoryMetadata & {
            _resolved?: IResolvedRepositoryMetadata;
        }) | undefined;
        /** Registers a repository binding (called by @repository) linking a repository to its model + datasource. */
        registerRepositoryBinding<Model_1 extends AbstractEntity = AbstractEntity<unknown>, DataSource_1 extends IDataSource = IDataSource<{}, import("../../../base/datasources").TAnyDataSourceSchema, {}>>(opts: IRepositoryBinding<Model_1, DataSource_1>): void;
        /** By class, walking up to the nearest decorated parent; by name only for callers holding a name. */
        getRepositoryBinding(opts: {
            target: Function;
        } | {
            name: string;
        }): IRepositoryBinding<AbstractEntity> | undefined;
        /** A class finds what was registered under it, and under a string equal to its name. */
        getDataSourceModelClasses(opts: {
            dataSource: string | TClass<IDataSource>;
        }): Set<TClass<AnyType>>;
        /**
         * Resolves and caches relations for a model entry - called lazily from buildSchema() so that
         * every `@model` class is registered first, which avoids circular-dependency ordering issues.
         * @internal
         */
        resolveModelRelations(modelMeta: IModelRegistryEntry): unknown;
        /**
         * Models registered for a datasource, relations resolved lazily. `schema`/`relations` stay
         * `unknown` - the registry is shared across connectors, so each connector narrows at its call
         * site.
         */
        getModels(opts: {
            dataSource: string | TClass<IDataSource>;
        }): Array<{
            tableName: string;
            schema: unknown;
            relations?: unknown;
        }>;
        /**
         * Like getModels but returns only resolved model classes - used by BaseSearchDataSource, which
         * has no pgTable to resolve.
         */
        getModelClasses(opts: {
            dataSource: string | TClass<IDataSource>;
        }): Array<TClass<unknown>>;
        /** The key a model occupies in `modelRegistry` - its table name, or its class name when it has none. */
        resolveModelKey(opts: {
            modelClass: TClass<AnyType>;
        }): string;
        /** Assembles table schemas + relations for a datasource's registered models. */
        buildSchema(opts: {
            dataSource: string | TClass<IDataSource>;
        }): {
            schema: Record<string, unknown>;
            relations: Record<string, unknown>;
        };
        hasModels(opts: {
            dataSource: string | TClass<IDataSource>;
        }): boolean;
        define: <Target extends object = object, Value = any>(opts: {
            target: Target;
            key: import("@venizia/ignis-inversion").TBindingKey;
            value: Value;
        }) => void;
        get: <Target extends object = object, Value_1 = any>(opts: {
            target: Target;
            key: import("@venizia/ignis-inversion").TBindingKey;
        }) => Value_1 | undefined;
        has: <Target extends object = object>(opts: {
            target: Target;
            key: import("@venizia/ignis-inversion").TBindingKey;
        }) => boolean;
        delete: <Target extends object = object>(opts: {
            target: Target;
            key: import("@venizia/ignis-inversion").TBindingKey;
        }) => boolean;
        getKeys: <Target extends object = object>(opts: {
            target: Target;
        }) => import("@venizia/ignis-inversion").TBindingKey[];
        getMethodNames: <T = any>(opts: {
            target: import("@venizia/ignis-inversion").TClass<T>;
        }) => string[];
        clearMetadata: <T extends object = object>(opts: {
            target: T;
        }) => void;
        setPropertyMetadata: <T extends object = object>(opts: {
            target: T;
            propertyName: string | symbol;
            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
        }) => void;
        getPropertiesMetadata: <T extends object = object>(opts: {
            target: T;
        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
        getPropertyMetadata: <T extends object = object>(opts: {
            target: T;
            propertyName: string | symbol;
        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
        setInjectMetadata: <T extends object = object>(opts: {
            target: T;
            index: number;
            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
        }) => void;
        getInjectMetadata: <T extends object = object>(opts: {
            target: T;
        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
        setBindingKey: <T extends object = object>(opts: {
            target: T;
            key: import("@venizia/ignis-inversion").TBindingKey;
            isProvisional?: boolean;
        }) => void;
        getBindingKey: <T extends object = object>(opts: {
            target: T;
        }) => import("@venizia/ignis-inversion").TBindingKey | undefined;
        scope: string;
        identifier: string;
        modelRegistry: Map<string, IModelRegistryEntry>;
        getModelMetadata: (opts: {
            target: object;
        }) => IModelMetadata | undefined;
    };
} & BaseClass;
//# sourceMappingURL=repository.mixin.d.ts.map